🛡️ Improve error handling and add defensive programming

Add robust error handling throughout the codebase to prevent crashes

This change implements more resilient error handling patterns across the app:

- Replace unwrap() calls with unwrap_or_else() to provide fallback values
- Add file extension handling with case-insensitive comparisons
- Implement file analyzer improvements with robust file type detection
- Enhance JSON parsing with proper error handling and recovery
- Add debug logging for parsing failures
- Add parking_lot::Mutex for more reliable mutex handling
- Improve error handling in regex operations
- Make file matching more robust in file analyzers module

These changes significantly improve the reliability and user experience by
preventing crashes and providing graceful error recovery.

Author: hyperb1iss

Cargo.lock

@@ -44,6 +44,7 @@ tokio-retry = "0.3.0"
 log = "0.4.22"
 futures = "0.3.30"
 schemars = "0.8.21"
+parking_lot = "0.12.1"
 
 [dev-dependencies]
 dotenv = "0.15.0"

Cargo.toml

@@ -108,6 +108,52 @@ impl ChangeAnalyzer {
                     _ => ChangeType::Modified,
                 };
 
+                let file_path = new_file.path().map_or_else(
+                    || {
+                        old_file
+                            .path()
+                            .map(|p| p.to_string_lossy().into_owned())
+                            .unwrap_or_default()
+                    },
+                    |p| p.to_string_lossy().into_owned(),
+                );
+
+                // Perform file-specific analysis based on file type
+                let mut analysis = Vec::new();
+
+                // Determine file type and add relevant analysis
+                if let Some(extension) = std::path::Path::new(&file_path).extension() {
+                    if let Some(ext_str) = extension.to_str() {
+                        match ext_str.to_lowercase().as_str() {
+                            "rs" => analysis.push("Rust source code changes".to_string()),
+                            "js" | "ts" => {
+                                analysis.push("JavaScript/TypeScript changes".to_string());
+                            }
+                            "py" => analysis.push("Python code changes".to_string()),
+                            "java" => analysis.push("Java code changes".to_string()),
+                            "c" | "cpp" | "h" => analysis.push("C/C++ code changes".to_string()),
+                            "md" => analysis.push("Documentation changes".to_string()),
+                            "json" | "yml" | "yaml" | "toml" => {
+                                analysis.push("Configuration changes".to_string());
+                            }
+                            _ => {}
+                        }
+                    }
+                }
+
+                // Add analysis based on change type
+                match change_type {
+                    ChangeType::Added => analysis.push("New file added".to_string()),
+                    ChangeType::Deleted => analysis.push("File removed".to_string()),
+                    ChangeType::Modified => {
+                        if file_path.contains("test") || file_path.contains("spec") {
+                            analysis.push("Test modifications".to_string());
+                        } else if file_path.contains("README") || file_path.contains("docs/") {
+                            analysis.push("Documentation updates".to_string());
+                        }
+                    }
+                }
+
                 let file_change = FileChange {
                     old_path: old_file
                         .path()
@@ -118,7 +164,7 @@ impl ChangeAnalyzer {
                         .map(|p| p.to_string_lossy().into_owned())
                         .unwrap_or_default(),
                     change_type,
-                    analysis: vec![], // TODO: Implement file-specific analysis if needed
+                    analysis,
                 };
 
                 file_changes.push(file_change);

src/changes/change_analyzer.rs

@@ -1,3 +1,4 @@
+use crate::log_debug;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -117,16 +118,47 @@ pub struct SectionItem {
 
 impl From<String> for ChangelogResponse {
     /// Converts a JSON string to a `ChangelogResponse`
-    #[allow(clippy::unwrap_used)] // todo: handle unwrap maybe use try_from instead
     fn from(value: String) -> Self {
-        serde_json::from_str(&value).unwrap()
+        serde_json::from_str(&value).unwrap_or_else(|e| {
+            log_debug!("Failed to parse ChangelogResponse: {}", e);
+            Self {
+                version: Some("Error".to_string()),
+                release_date: Some("Error".to_string()),
+                sections: HashMap::new(),
+                breaking_changes: Vec::new(),
+                metrics: ChangeMetrics {
+                    total_commits: 0,
+                    files_changed: 0,
+                    insertions: 0,
+                    deletions: 0,
+                    total_lines_changed: 0,
+                },
+            }
+        })
     }
 }
 
 impl From<String> for ReleaseNotesResponse {
     /// Converts a JSON string to a `ReleaseNotesResponse`
-    #[allow(clippy::unwrap_used)] // todo: handle unwrap maybe use try_from instead
     fn from(value: String) -> Self {
-        serde_json::from_str(&value).unwrap()
+        serde_json::from_str(&value).unwrap_or_else(|e| {
+            log_debug!("Failed to parse ReleaseNotesResponse: {}", e);
+            Self {
+                version: Some("Error".to_string()),
+                release_date: Some("Error".to_string()),
+                summary: format!("Error parsing response: {e}"),
+                highlights: Vec::new(),
+                sections: Vec::new(),
+                breaking_changes: Vec::new(),
+                upgrade_notes: Vec::new(),
+                metrics: ChangeMetrics {
+                    total_commits: 0,
+                    files_changed: 0,
+                    insertions: 0,
+                    deletions: 0,
+                    total_lines_changed: 0,
+                },
+            }
+        })
     }
 }

src/changes/models.rs

@@ -5,11 +5,17 @@ use super::{
 use crate::common::{get_combined_instructions, DetailLevel};
 use crate::config::Config;
 use crate::gitmoji::get_gitmoji_list;
+use crate::log_debug;
 
-#[allow(clippy::unwrap_used)] // todo: handle unwrap
 pub fn create_changelog_system_prompt(config: &Config) -> String {
     let changelog_schema = schemars::schema_for!(ChangelogResponse);
-    let changelog_schema_str = serde_json::to_string_pretty(&changelog_schema).unwrap();
+    let changelog_schema_str = match serde_json::to_string_pretty(&changelog_schema) {
+        Ok(schema) => schema,
+        Err(e) => {
+            log_debug!("Failed to serialize changelog schema: {}", e);
+            "{ \"error\": \"Failed to serialize schema\" }".to_string()
+        }
+    };
 
     let mut prompt = String::from(
         "You are an AI assistant specialized in generating clear, concise, and informative changelogs for software projects. \
@@ -116,10 +122,15 @@ pub fn create_changelog_system_prompt(config: &Config) -> String {
     prompt
 }
 
-#[allow(clippy::unwrap_used)] // todo: handle unwrap maybe use try_from instead
 pub fn create_release_notes_system_prompt(config: &Config) -> String {
     let release_notes_schema = schemars::schema_for!(ReleaseNotesResponse);
-    let release_notes_schema_str = serde_json::to_string_pretty(&release_notes_schema).unwrap();
+    let release_notes_schema_str = match serde_json::to_string_pretty(&release_notes_schema) {
+        Ok(schema) => schema,
+        Err(e) => {
+            log_debug!("Failed to serialize release notes schema: {}", e);
+            "{ \"error\": \"Failed to serialize schema\" }".to_string()
+        }
+    };
 
     let mut prompt = String::from(
         "You are an AI assistant specialized in generating comprehensive and user-friendly release notes for software projects. \

src/changes/prompt.rs

@@ -11,14 +11,15 @@ pub async fn get_readme_summary(
     config: &Config,
     provider_type: &LLMProviderType,
 ) -> Result<Option<String>> {
-    if let Some(readme_content) = git_repo
+    match git_repo
         .get_readme_at_commit(commit_ish)
         .context("Failed to get README at specified commit")?
     {
-        let summary = summarize_readme(config, provider_type, &readme_content).await?;
-        Ok(Some(summary))
-    } else {
-        Ok(None)
+        Some(readme_content) => {
+            let summary = summarize_readme(config, provider_type, &readme_content).await?;
+            Ok(Some(summary))
+        }
+        _ => Ok(None),
     }
 }
 

src/changes/readme_reader.rs

@@ -200,7 +200,6 @@ impl Config {
 }
 
 impl Default for Config {
-    #[allow(clippy::unwrap_used)] // todo: handle unwrap
     fn default() -> Self {
         let mut providers = HashMap::new();
         for provider in get_available_providers() {
@@ -210,10 +209,20 @@ impl Default for Config {
             );
         }
 
+        // Default to OpenAI if available, otherwise use the first available provider
+        let default_provider = if providers.contains_key("OpenAI") {
+            "OpenAI".to_string()
+        } else {
+            providers.keys().next().map_or_else(
+                || "OpenAI".to_string(), // Fallback even if no providers (should never happen)
+                std::clone::Clone::clone,
+            )
+        };
+
         Self {
-            default_provider: get_available_providers().first().unwrap().to_string(),
+            default_provider,
             providers,
-            use_gitmoji: true,
+            use_gitmoji: default_gitmoji(),
             instructions: String::new(),
             instruction_preset: default_instruction_preset(),
             temp_instructions: None,

src/config.rs

@@ -1,3 +1,4 @@
+use crate::log_debug;
 use crate::token_optimizer::TokenOptimizer;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@@ -40,9 +41,15 @@ pub struct GeneratedMessage {
 }
 
 impl From<String> for GeneratedMessage {
-    #[allow(clippy::unwrap_used)] // todo: handle error maybe replace with try_from
     fn from(value: String) -> Self {
-        serde_json::from_str(&value).unwrap()
+        serde_json::from_str(&value).unwrap_or_else(|e| {
+            log_debug!("Failed to parse GeneratedMessage: {}", e);
+            GeneratedMessage {
+                emoji: None,
+                title: "Parsing Error".to_string(),
+                message: format!("Failed to parse response: {e}"),
+            }
+        })
     }
 }
 

src/context.rs

@@ -35,11 +35,10 @@ impl FileAnalyzer for JavaScriptAnalyzer {
         "JavaScript/TypeScript source file"
     }
 
-    #[allow(clippy::case_sensitive_file_extension_comparisons)] // todo: check if we should compare case-insensitively
     fn extract_metadata(&self, file: &str, content: &str) -> ProjectMetadata {
         let mut metadata = ProjectMetadata {
             language: Some(
-                if file.ends_with(".ts") {
+                if file.to_lowercase().ends_with(".ts") {
                     "TypeScript"
                 } else {
                     "JavaScript"

src/file_analyzers/javascript.rs

@@ -1,5 +1,6 @@
 use super::{FileAnalyzer, ProjectMetadata};
 use crate::context::StagedFile;
+use crate::log_debug;
 use regex::Regex;
 use std::collections::HashSet;
 
@@ -82,20 +83,31 @@ impl JsonAnalyzer {
     }
 }
 
-#[allow(clippy::unwrap_used)] // todo: handle unwrap maybe use try_from instead
 fn extract_modified_top_level_keys(diff: &str) -> Option<Vec<String>> {
     let lines: Vec<&str> = diff.lines().collect();
-    let re = Regex::new(r#"^[+-]\s*"(\w+)"\s*:"#).expect("Could not compile regex");
+    let re = match Regex::new(r#"^[+-]\s*"(\w+)"\s*:"#) {
+        Ok(re) => re,
+        Err(e) => {
+            log_debug!("Failed to compile regex: {}", e);
+            return None;
+        }
+    };
     let mut keys = HashSet::new();
 
     for (i, line) in lines.iter().enumerate() {
         if let Some(cap) = re.captures(line) {
-            let key = cap.get(1).unwrap().as_str();
-            let prev_line = if i > 0 { lines[i - 1] } else { "" };
-            let next_line = lines.get(i + 1).unwrap_or(&"");
-
-            if !prev_line.trim().ends_with('{') && !next_line.trim().starts_with('}') {
-                keys.insert(key.to_string());
+            if let Some(key_match) = cap.get(1) {
+                let key = key_match.as_str();
+                let prev_line = if i > 0 { lines[i - 1] } else { "" };
+                let next_line = if i + 1 < lines.len() {
+                    lines[i + 1]
+                } else {
+                    ""
+                };
+
+                if !prev_line.trim().ends_with('{') && !next_line.trim().starts_with('}') {
+                    keys.insert(key.to_string());
+                }
             }
         }
     }