refactor: Improve error handling and code quality (Phase 2 & 3)

This release focuses on production readiness by improving error handling
and code quality across the codebase.

Phase 2 - Error Handling Improvements:
- Replaced 19 production unwrap() calls with proper error handling
- Used .map_err() to convert errors to FerrixError with context
- Used .unwrap_or() and .unwrap_or_else() for safe defaults
- Used match statements for explicit error handling
- Improved error messages with contextual information

Files improved:
- src/server/recording.rs: Fixed duration_since() unwrap calls
- src/plugin/runtime.rs: Fixed lock().unwrap() calls
- src/transport/mosh.rs: Fixed try_into() and option unwraps
- src/server/hooks.rs: Fixed strip_prefix() unwrap
- src/input/chord.rs: Fixed last() unwrap
- src/ai/assistant.rs: Fixed partial_cmp() unwrap
- src/server/timetravel.rs: Fixed first()/last() unwraps
- src/server/versioning.rs: Fixed as_ref() unwrap

Phase 3 - Code Quality (Clippy):
- Fixed all clippy warnings in production code
- Removed unused std::io::Write import
- Replaced manual ASCII range check with .is_ascii_lowercase()
- Added #[allow(dead_code)] to intentionally unused methods
- Fixed test compilation errors for protocol message fields

Testing:
- All tests compile and pass
- Release build succeeds with zero warnings
- Production code is now clippy-clean

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: DavidLiedle

CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.20.8] - 2025-10-09
+
+### Changed
+- **Error Handling**: Improved error handling across production code
+  - Replaced 19 production unwrap() calls with proper error handling
+  - Uses `.map_err()`, `.unwrap_or()`, and match statements for safe handling
+  - Added context to error messages for better debugging
+  - Files improved: recording.rs, plugin/runtime.rs, transport/mosh.rs, server/hooks.rs, input/chord.rs, ai/assistant.rs, server/timetravel.rs, server/versioning.rs
+
+### Fixed
+- **Code Quality**: Fixed all clippy warnings in production code
+  - Removed unused imports
+  - Simplified manual ASCII range checks to use `.is_ascii_lowercase()`
+  - Added `#[allow(dead_code)]` to intentionally unused helper methods
+  - Fixed test compilation errors for protocol message fields
+
 ## [0.20.7] - 2025-10-09
 
 ### Fixed

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "ferrix"
-version = "0.20.7"
+version = "0.20.8"
 edition = "2021"
 authors = ["David Liedle", "Claude <noreply@anthropic.com>"]
 description = "A modern terminal multiplexer built with Rust, inspired by tmux and GNU Screen"

Cargo.toml

@@ -164,7 +164,7 @@ impl CommandAssistant {
         suggestions.extend(self.suggest_optimizations());
 
         // Sort by confidence
-        suggestions.sort_by(|a, b| b.confidence.partial_cmp(&a.confidence).unwrap());
+        suggestions.sort_by(|a, b| b.confidence.partial_cmp(&a.confidence).unwrap_or(std::cmp::Ordering::Equal));
 
         // Cache results
         self.suggestions_cache.insert(partial_command.to_string(), suggestions.clone());

src/ai/assistant.rs

@@ -338,6 +338,7 @@ impl Client {
         Err(FerrixError::NotConnected)
     }
 
+    #[allow(dead_code)]
     async fn run_attached(&mut self) -> Result<()> {
         // Only enable raw mode if we're in an interactive terminal
         let is_tty = std::io::stdin().is_terminal();
@@ -671,7 +672,7 @@ impl Client {
                 if key_event.modifiers == KeyModifiers::CONTROL {
                     // Convert to lowercase for control character calculation
                     let lower_c = c.to_ascii_lowercase();
-                    if lower_c >= 'a' && lower_c <= 'z' {
+                    if lower_c.is_ascii_lowercase() {
                         data.push((lower_c as u8) - b'a' + 1);
                     } else if c == '@' {
                         data.push(0); // Ctrl-@ is NUL
@@ -1817,7 +1818,6 @@ impl Client {
     }
 
     async fn draw_pane_content(&mut self, pane: &PaneInfo) -> Result<()> {
-        use std::io::Write;
         use crossterm::style::{SetForegroundColor, SetBackgroundColor, SetAttribute, ResetColor};
 
         // Use a buffer to collect all output before flushing
@@ -2380,9 +2380,7 @@ impl Client {
         execute!(stdout, MoveTo(0, rows - 1))?;
 
         // Build status bar content
-        let session_name = self.attached_session_name
-            .as_ref()
-            .map(|s| s.clone())
+        let session_name = self.attached_session_name.clone()
             .unwrap_or_else(|| "No Session".to_string());
 
         let window_info = if let Some(layout) = &self.current_layout {

src/client/mod.rs

@@ -146,7 +146,8 @@ impl ChordDetector {
         let chord: Vec<KeyEvent> = keys.iter().map(|k| {
             let parts: Vec<&str> = k.split('+').collect();
             let (modifiers, code) = if parts.len() > 1 {
-                (parts[0..parts.len()-1].join("+"), parts.last().unwrap().to_string())
+                (parts[0..parts.len()-1].join("+"),
+                 parts.last().map(|s| s.to_string()).unwrap_or_default())
             } else {
                 (String::new(), k.to_string())
             };

src/input/chord.rs

@@ -117,15 +117,17 @@ impl PluginRuntime {
 
         // Instantiate the module
         let instance = {
-            let mut store_guard = store.lock().unwrap();
+            let mut store_guard = store.lock()
+                .map_err(|e| FerrixError::Plugin(format!("Failed to lock plugin store: {}", e)))?;
             linker.instantiate(&mut *store_guard, &module)
                 .map_err(|e| FerrixError::Plugin(format!("Failed to instantiate plugin: {}", e)))?
         };
 
         // Get exported functions
         let mut exports = HashMap::new();
         {
-            let mut store_guard = store.lock().unwrap();
+            let mut store_guard = store.lock()
+                .map_err(|e| FerrixError::Plugin(format!("Failed to lock plugin store: {}", e)))?;
             for export_name in &manifest.exports {
                 if let Some(func) = instance.get_func(&mut *store_guard, export_name) {
                     exports.insert(export_name.clone(), func);
@@ -135,7 +137,8 @@ impl PluginRuntime {
 
         // Initialize the plugin
         {
-            let mut store_guard = store.lock().unwrap();
+            let mut store_guard = store.lock()
+                .map_err(|e| FerrixError::Plugin(format!("Failed to lock plugin store: {}", e)))?;
             if let Some(init_func) = instance.get_func(&mut *store_guard, "plugin_init") {
                 init_func.call(&mut *store_guard, &[], &mut [])
                     .map_err(|e| FerrixError::Plugin(format!("Plugin initialization failed: {}", e)))?;
@@ -174,7 +177,8 @@ impl PluginRuntime {
         if let Some(plugin) = plugins.remove(plugin_id) {
             // Call cleanup if available
             if let Some(cleanup_func) = plugin.exports.get("plugin_cleanup") {
-                let mut store_guard = plugin.store.lock().unwrap();
+                let mut store_guard = plugin.store.lock()
+                    .map_err(|e| FerrixError::Plugin(format!("Failed to lock plugin store: {}", e)))?;
                 cleanup_func.call(&mut *store_guard, &[], &mut [])
                     .map_err(|e| FerrixError::Plugin(format!("Plugin cleanup failed: {}", e)))?;
             }
@@ -207,7 +211,13 @@ impl PluginRuntime {
         for (_id, plugin) in plugins.iter() {
             if let Some(handle_func) = plugin.exports.get("handle_command") {
                 // Get a lock on the store and update context
-                let mut store_guard = plugin.store.lock().unwrap();
+                let mut store_guard = match plugin.store.lock() {
+                    Ok(guard) => guard,
+                    Err(e) => {
+                        warn!("Failed to lock plugin store: {}", e);
+                        continue;
+                    }
+                };
                 store_guard.data_mut().context = context.clone();
 
                 // Serialize command to pass to WASM
@@ -248,7 +258,13 @@ impl PluginRuntime {
                     let hook_name = format!("hook_{:?}", hook).to_lowercase();
                     if let Some(hook_func) = plugin.exports.get(&hook_name) {
                         // Get a lock on the store and update context
-                        let mut store_guard = plugin.store.lock().unwrap();
+                        let mut store_guard = match plugin.store.lock() {
+                            Ok(guard) => guard,
+                            Err(e) => {
+                                warn!("Failed to lock plugin store: {}", e);
+                                continue;
+                            }
+                        };
                         store_guard.data_mut().context = context.clone();
 
                         // Call the hook function
@@ -278,7 +294,13 @@ impl PluginRuntime {
         for (_id, plugin) in plugins.iter() {
             if let Some(event_func) = plugin.exports.get("handle_event") {
                 // Get a lock on the store and add event to queue
-                let mut store_guard = plugin.store.lock().unwrap();
+                let mut store_guard = match plugin.store.lock() {
+                    Ok(guard) => guard,
+                    Err(e) => {
+                        warn!("Failed to lock plugin store: {}", e);
+                        continue;
+                    }
+                };
                 store_guard.data_mut().event_queue.push(event.clone());
 
                 // Call the event handler function
@@ -416,9 +438,7 @@ impl PluginRuntime {
 
         // Register hooks based on exported functions
         for export in &manifest.exports {
-            if export.starts_with("hook_") {
-                // Parse hook type from function name
-                let hook_name = export.strip_prefix("hook_").unwrap();
+            if let Some(hook_name) = export.strip_prefix("hook_") {
 
                 // Map to PluginHook enum (simplified)
                 let hook = match hook_name {

src/plugin/runtime.rs

@@ -30,6 +30,7 @@ mod protocol_tests {
         let session_id = SessionId(Uuid::new_v4());
         let message = ClientMessage::CreateSession {
             name: Some("test-session".to_string()),
+            working_dir: None,
         };
 
         // Test encoding
@@ -47,7 +48,7 @@ mod protocol_tests {
         let session_id = SessionId(Uuid::new_v4());
         let message = ServerMessage::SessionCreated {
             session_id,
-            session_name: "test-session".to_string(),
+            name: "test-session".to_string(),
         };
 
         // Test encoding
@@ -65,6 +66,7 @@ mod protocol_tests {
         let session_id = SessionId(Uuid::new_v4());
         let original_message = ClientMessage::CreateSession {
             name: Some("test-session".to_string()),
+            working_dir: None,
         };
 
         // Encode message
@@ -76,8 +78,8 @@ mod protocol_tests {
             Some(decoded_message) => {
                 // Compare messages (would need PartialEq implementation)
                 match (&original_message, &decoded_message) {
-                    (ClientMessage::CreateSession { name: name1 },
-                     ClientMessage::CreateSession { name: name2 }) => {
+                    (ClientMessage::CreateSession { name: name1, working_dir: _ },
+                     ClientMessage::CreateSession { name: name2, working_dir: _ }) => {
                         assert_eq!(name1, name2);
                     }
                     _ => panic!("Message types don't match"),
@@ -190,6 +192,7 @@ mod protocol_tests {
 
         let message = ClientMessage::CreateSession {
             name: Some("test".to_string()),
+            working_dir: None,
         };
 
         // Encode message
@@ -278,13 +281,14 @@ mod protocol_tests {
 
                 let message = ClientMessage::CreateSession {
                     name: Some(format!("session-{}", i)),
+                    working_dir: None,
                 };
 
                 codec.encode(message, &mut buf).unwrap();
                 assert!(!buf.is_empty());
 
                 match codec.decode(&mut buf).unwrap() {
-                    Some(ClientMessage::CreateSession { name }) => {
+                    Some(ClientMessage::CreateSession { name, working_dir: _ }) => {
                         assert_eq!(name, Some(format!("session-{}", i)));
                     }
                     _ => panic!("Wrong message type"),

src/protocol/tests.rs

@@ -147,8 +147,8 @@ impl HookEvent {
 
             // Command hooks
             name if name.starts_with("after-") => {
-                let cmd = name.strip_prefix("after-").unwrap();
-                Some(HookEvent::AfterCommand(cmd.to_string()))
+                name.strip_prefix("after-")
+                    .map(|cmd| HookEvent::AfterCommand(cmd.to_string()))
             }
 
             _ => None,

src/server/hooks.rs

@@ -175,7 +175,7 @@ impl SessionRecorder {
         // Calculate duration
         let duration = SystemTime::now()
             .duration_since(self.start_time)
-            .unwrap();
+            .unwrap_or(Duration::from_secs(0));
         self.metadata.duration_ms = Some(duration.as_millis() as u64);
 
         // Write final metadata
@@ -245,7 +245,7 @@ impl SessionRecorder {
             let event = RecordingEvent::Output {
                 timestamp: SystemTime::now()
                     .duration_since(self.start_time)
-                    .unwrap()
+                    .unwrap_or(Duration::from_secs(0))
                     .as_millis() as u64,
                 pane_id,
                 data,
@@ -263,7 +263,7 @@ impl SessionRecorder {
             let event = RecordingEvent::Input {
                 timestamp: SystemTime::now()
                     .duration_since(self.start_time)
-                    .unwrap()
+                    .unwrap_or(Duration::from_secs(0))
                     .as_millis() as u64,
                 pane_id,
                 data,
@@ -280,7 +280,7 @@ impl SessionRecorder {
         let event = RecordingEvent::Resize {
             timestamp: SystemTime::now()
                 .duration_since(self.start_time)
-                .unwrap()
+                .unwrap_or(Duration::from_secs(0))
                 .as_millis() as u64,
             pane_id,
             cols,
@@ -537,7 +537,9 @@ impl SessionPlayer {
             }
         });
 
-        writeln!(file, "{}", serde_json::to_string(&header).unwrap())
+        let header_str = serde_json::to_string(&header)
+            .map_err(|e| FerrixError::Other(format!("Failed to serialize header: {}", e)))?;
+        writeln!(file, "{}", header_str)
             .map_err(|e| FerrixError::Other(format!("Failed to write header: {}", e)))?;
 
         // Write events
@@ -546,7 +548,9 @@ impl SessionPlayer {
                 let timestamp_sec = *timestamp as f64 / 1000.0;
                 let text = String::from_utf8_lossy(data);
                 let event_array = serde_json::json!([timestamp_sec, "o", text]);
-                writeln!(file, "{}", serde_json::to_string(&event_array).unwrap())
+                let event_str = serde_json::to_string(&event_array)
+                    .map_err(|e| FerrixError::Other(format!("Failed to serialize event: {}", e)))?;
+                writeln!(file, "{}", event_str)
                     .map_err(|e| FerrixError::Other(format!("Failed to write event: {}", e)))?;
             }
         }
@@ -561,9 +565,10 @@ impl SessionPlayer {
 
         writeln!(file, "# Ferrix Session Recording")?;
         writeln!(file, "# Session: {} ({:?})", self.metadata.session_name, self.metadata.session_id)?;
-        writeln!(file, "# Date: {}", chrono::DateTime::<chrono::Utc>::from_timestamp(
+        let created_date = chrono::DateTime::<chrono::Utc>::from_timestamp(
             self.metadata.created_at as i64, 0
-        ).unwrap())?;
+        ).unwrap_or_else(chrono::Utc::now);
+        writeln!(file, "# Date: {}", created_date)?;
         writeln!(file, "# Duration: {:?}ms\n", self.metadata.duration_ms)?;
 
         for event in &self.events {