refactor: [#116] replace Box<dyn Error> with concrete error enums in dependency-installer

- Replace all Box<dyn std::error::Error> with strongly-typed enum errors
- Implement From traits for automatic error conversions using ? operator
- Create ExitCode enum for type-safe CLI exit codes
- Move AppError::to_exit_code logic from binary to AppError method
- Relocate DetectionError to detector module where it originates
- Relocate CommandError to command module where it originates
- Remove now-empty errors.rs module

Error hierarchy established:
- AppError (app.rs) - top-level application errors
  - CheckFailed wraps CheckError
  - ListFailed wraps ListError
- CheckError (handlers/check.rs) - check command errors
  - CheckAllFailed wraps CheckAllToolsError
  - CheckSpecificFailed wraps CheckSpecificToolError
- CheckAllToolsError - checking all dependencies
  - MissingDependencies with counts
  - DependencyCheckFailed wraps DetectionError
- CheckSpecificToolError - checking specific tool
  - ParseFailed wraps ParseToolNameError
  - ToolNotInstalled with tool name
  - DetectionFailed wraps DetectionError
- ParseToolNameError - tool name parsing
  - UnknownTool with name and available_tools
- ListError (handlers/list.rs) - list command errors
  - DependencyCheckFailed wraps DetectionError
- DetectionError (detector/mod.rs) - tool detection
- CommandError (command.rs) - command execution
- ExitCode enum (app.rs) - type-safe exit codes

All errors use thiserror with #[error] and #[source] attributes for
complete traceability. Pattern matching now possible on all error types.

Author: josecelano

packages/dependency-installer/src/app.rs

@@ -3,10 +3,101 @@
 //! This module contains the core application logic for running the CLI.
 
 use clap::Parser;
+use thiserror::Error;
 
 use crate::cli::{Cli, Commands};
+use crate::handlers::check::CheckError;
+use crate::handlers::list::ListError;
 use crate::DependencyManager;
 
+/// Exit codes for the CLI application
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ExitCode {
+    /// Success - all checks passed
+    Success = 0,
+    /// Missing dependencies (tool not installed or missing dependencies)
+    MissingDependencies = 1,
+    /// Invalid arguments (unknown tool name)
+    InvalidArguments = 2,
+    /// Internal error (detection failures or other errors)
+    InternalError = 3,
+}
+
+impl From<ExitCode> for i32 {
+    fn from(code: ExitCode) -> Self {
+        code as i32
+    }
+}
+
+/// Errors that can occur when running the application
+#[derive(Debug, Error)]
+pub enum AppError {
+    /// Failed to execute the check command
+    ///
+    /// This occurs when the check command fails to verify dependencies.
+    #[error("Check command failed: {source}")]
+    CheckFailed {
+        #[source]
+        source: CheckError,
+    },
+
+    /// Failed to execute the list command
+    ///
+    /// This occurs when the list command fails to list dependencies.
+    #[error("List command failed: {source}")]
+    ListFailed {
+        #[source]
+        source: ListError,
+    },
+}
+
+impl AppError {
+    /// Convert the error to an appropriate exit code for the CLI
+    ///
+    /// # Exit Codes
+    ///
+    /// - `ExitCode::MissingDependencies`: Tool not installed or missing dependencies
+    /// - `ExitCode::InvalidArguments`: Unknown tool name
+    /// - `ExitCode::InternalError`: Detection failures or other errors
+    #[must_use]
+    pub fn to_exit_code(&self) -> ExitCode {
+        use crate::handlers::check::{
+            CheckAllToolsError, CheckError, CheckSpecificToolError, ParseToolNameError,
+        };
+
+        match self {
+            Self::CheckFailed { source } => match source {
+                CheckError::CheckAllFailed { source } => match source {
+                    CheckAllToolsError::MissingDependencies { .. } => ExitCode::MissingDependencies,
+                    CheckAllToolsError::DependencyCheckFailed { .. } => ExitCode::InternalError,
+                },
+                CheckError::CheckSpecificFailed { source } => match source {
+                    CheckSpecificToolError::ParseFailed {
+                        source: ParseToolNameError::UnknownTool { .. },
+                    } => ExitCode::InvalidArguments,
+                    CheckSpecificToolError::ToolNotInstalled { .. } => {
+                        ExitCode::MissingDependencies
+                    }
+                    CheckSpecificToolError::DetectionFailed { .. } => ExitCode::InternalError,
+                },
+            },
+            Self::ListFailed { .. } => ExitCode::InternalError,
+        }
+    }
+}
+
+impl From<CheckError> for AppError {
+    fn from(source: CheckError) -> Self {
+        Self::CheckFailed { source }
+    }
+}
+
+impl From<ListError> for AppError {
+    fn from(source: ListError) -> Self {
+        Self::ListFailed { source }
+    }
+}
+
 /// Run the CLI application
 ///
 /// # Errors
@@ -15,7 +106,7 @@ use crate::DependencyManager;
 /// - Dependencies are missing
 /// - Invalid tool name is provided
 /// - Internal error occurs during dependency checking
-pub fn run() -> Result<(), Box<dyn std::error::Error>> {
+pub fn run() -> Result<(), AppError> {
     let cli = Cli::parse();
 
     // Initialize tracing based on verbose flag
@@ -29,7 +120,9 @@ pub fn run() -> Result<(), Box<dyn std::error::Error>> {
     let manager = DependencyManager::new();
 
     match cli.command {
-        Commands::Check { tool } => crate::handlers::check::handle_check(&manager, tool),
-        Commands::List => crate::handlers::list::handle_list(&manager),
+        Commands::Check { tool } => crate::handlers::check::handle_check(&manager, tool)?,
+        Commands::List => crate::handlers::list::handle_list(&manager)?,
     }
+
+    Ok(())
 }

packages/dependency-installer/src/bin/dependency-installer.rs

@@ -12,34 +12,16 @@
 
 use std::process;
 
-use torrust_dependency_installer::app;
+use torrust_dependency_installer::app::{self, ExitCode};
 
 fn main() {
     let exit_code = match app::run() {
-        Ok(()) => 0,
+        Ok(()) => ExitCode::Success,
         Err(e) => {
             eprintln!("Error: {e}");
-            error_to_exit_code(e.as_ref())
+            e.to_exit_code()
         }
     };
 
-    process::exit(exit_code);
-}
-
-/// Determine exit code based on error type
-///
-/// # Exit Codes
-///
-/// - 1: Missing dependencies (contains "not installed" or "Missing")
-/// - 2: Invalid arguments (contains "Unknown tool" or "invalid")
-/// - 3: Internal error (all other errors)
-fn error_to_exit_code(error: &dyn std::error::Error) -> i32 {
-    let error_msg = error.to_string();
-    if error_msg.contains("not installed") || error_msg.contains("Missing") {
-        1 // Missing dependency
-    } else if error_msg.contains("Unknown tool") || error_msg.contains("invalid") {
-        2 // Invalid argument
-    } else {
-        3 // Internal error
-    }
+    process::exit(exit_code.into());
 }

packages/dependency-installer/src/command.rs

@@ -1,6 +1,20 @@
 use std::process::Command;
 
-use crate::errors::CommandError;
+use thiserror::Error;
+
+/// Error types for command execution utilities
+#[derive(Debug, Error)]
+pub enum CommandError {
+    #[error("Failed to execute command '{command}': {source}")]
+    ExecutionFailed {
+        command: String,
+        #[source]
+        source: std::io::Error,
+    },
+
+    #[error("Command '{command}' not found in PATH")]
+    CommandNotFound { command: String },
+}
 
 /// Check if a command exists in the system PATH
 ///

packages/dependency-installer/src/detector/ansible.rs

@@ -1,8 +1,8 @@
 use tracing::info;
 
 use crate::command::command_exists;
-use crate::detector::ToolDetector;
-use crate::errors::DetectionError;
+
+use super::{DetectionError, ToolDetector};
 
 /// Detector for `Ansible` tool
 pub struct AnsibleDetector;

packages/dependency-installer/src/detector/cargo_machete.rs

@@ -1,8 +1,8 @@
 use tracing::info;
 
 use crate::command::command_exists;
-use crate::detector::ToolDetector;
-use crate::errors::DetectionError;
+
+use super::{DetectionError, ToolDetector};
 
 /// Detector for `cargo-machete` tool
 pub struct CargoMacheteDetector;

packages/dependency-installer/src/detector/lxd.rs

@@ -1,8 +1,8 @@
 use tracing::info;
 
 use crate::command::command_exists;
-use crate::detector::ToolDetector;
-use crate::errors::DetectionError;
+
+use super::{DetectionError, ToolDetector};
 
 /// Detector for `LXD` tool
 pub struct LxdDetector;

packages/dependency-installer/src/detector/mod.rs

@@ -3,13 +3,27 @@ pub mod cargo_machete;
 pub mod lxd;
 pub mod opentofu;
 
-use crate::errors::DetectionError;
+use thiserror::Error;
 
 pub use ansible::AnsibleDetector;
 pub use cargo_machete::CargoMacheteDetector;
 pub use lxd::LxdDetector;
 pub use opentofu::OpenTofuDetector;
 
+/// Error types for detection operations
+#[derive(Debug, Error)]
+pub enum DetectionError {
+    #[error("Failed to detect tool '{tool}': {source}")]
+    DetectionFailed {
+        tool: String,
+        #[source]
+        source: std::io::Error,
+    },
+
+    #[error("Command execution failed for tool '{tool}': {message}")]
+    CommandFailed { tool: String, message: String },
+}
+
 /// Trait for detecting if a tool is installed
 pub trait ToolDetector {
     /// Get the tool name for display purposes

packages/dependency-installer/src/detector/opentofu.rs

@@ -1,8 +1,8 @@
 use tracing::info;
 
 use crate::command::command_exists;
-use crate::detector::ToolDetector;
-use crate::errors::DetectionError;
+
+use super::{DetectionError, ToolDetector};
 
 /// Detector for `OpenTofu` tool
 pub struct OpenTofuDetector;