Merge #122: Create detection logic package for development dependencies

eaa0acc refactor: [#114] rename tests to follow it_should_ convention (Jose Celano)
91d2eb3 fix: [#114] use inline format args in example (copilot-swe-agent[bot])
04754eb feat: [#114] add example demonstrating dependency checking (copilot-swe-agent[bot])
07cc42a docs: [#114] add documentation for platform support and detector creation (copilot-swe-agent[bot])
48b5c0f feat: [#114] create detection logic package (copilot-swe-agent[bot])
848b331 Initial plan (copilot-swe-agent[bot])

Pull request description:

  ## Create Detection Logic Package

  Implementing detection logic for development dependencies (cargo-machete, OpenTofu, Ansible, LXD) following the linting package pattern.

  ### Implementation Plan

  - [x] Create package structure at `packages/dependency-installer/`
    - [x] Create directory structure
    - [x] Create Cargo.toml with dependencies (tracing, thiserror)
    - [x] Add to workspace Cargo.toml
    - [x] Create README.md
  - [x] Define core abstractions
    - [x] ToolDetector trait in `src/detector/mod.rs`
    - [x] DetectionError enum in `src/errors.rs`
    - [x] Dependency enum for tool types
    - [x] CheckResult struct for detection results
  - [x] Implement command utilities in `src/command.rs`
    - [x] command_exists() function
    - [x] execute_command() function
    - [x] CommandError type
  - [x] Implement 4 detector structs
    - [x] CargoMacheteDetector in `src/detector/cargo_machete.rs`
    - [x] OpenTofuDetector in `src/detector/opentofu.rs`
    - [x] AnsibleDetector in `src/detector/ansible.rs`
    - [x] LxdDetector in `src/detector/lxd.rs`
  - [x] Create DependencyManager in `src/manager.rs`
    - [x] new() to create with all detectors
    - [x] check_all() to check all dependencies
    - [x] get_detector() to get specific detector
  - [x] Add library exports in `src/lib.rs`
  - [x] Write comprehensive unit tests
    - [x] Test each detector implementation
    - [x] Test DependencyManager functionality
    - [x] Test error handling
  - [x] Add working example demonstrating usage
  - [x] Run linting, build, and verify
    - [x] cargo build ✓
    - [x] cargo test ✓ (22 tests + 2 doctests passing)
    - [x] cargo run --bin linter all ✓
  - [x] Address code review feedback
    - [x] Document Unix-specific `which` command usage
    - [x] Clarify detector creation pattern in DependencyManager
  - [x] Fix clippy linting issue
    - [x] Use inline format args in example

  ### Summary

  Successfully created the `packages/dependency-installer` package with:

  - **ToolDetector trait**: Abstract interface for tool detection with `name()` and `is_installed()` methods
  - **4 Detector implementations**: CargoMacheteDetector, OpenTofuDetector, AnsibleDetector, LxdDetector
  - **DependencyManager**: Orchestrates all detectors with `check_all()` and `get_detector()` methods
  - **Command utilities**: Helper functions for command execution (`command_exists`, `execute_command`)
  - **Comprehensive testing**: 22 unit tests + 2 doc tests covering all functionality
  - **Error handling**: Clear error types (DetectionError, CommandError) with context
  - **Logging**: Structured logging with tracing for all operations
  - **Documentation**: Platform support notes and implementation clarifications
  - **Example**: Working example demonstrating dependency checking

  All linters pass, all tests pass, workspace builds successfully, and the package follows the linting package pattern.

  ### Security Summary

  No security vulnerabilities identified. The package performs read-only operations:
  - Executes `which` command to check for tool existence
  - No file system modifications
  - No network operations
  - No user input processing
  - No credential handling

  ### Next Steps

  This completes Phase 1 of Issue #114. The next phases will add:
  - **Phase 2 (Issue #115)**: CLI binary with check command
  - **Phase 3 (Issue #116)**: Docker test infrastructure
  - **Phase 4 (Issue #117)**: Installation logic

  <!-- START COPILOT CODING AGENT SUFFIX -->

  <details>

  <summary>Original prompt</summary>

  >
  > ----
  >
  > *This section details on the original issue you should resolve*
  >
  > <issue_title>Create Detection Logic Package</issue_title>
  > <issue_description>**Parent Issue**: #113 - Create Dependency Installation Package for E2E Tests
  > **Depends On**: None (first phase)
  > **Epic**: #112 - Refactor and Improve E2E Test Execution
  >
  > ## Overview
  >
  > Create the package structure and implement detection logic to check if development dependencies (cargo-machete, OpenTofu, Ansible, LXD) are installed.
  >
  > This is **Phase 1 of 4** for building the dependency installation package.
  >
  > ## Objectives
  >
  > - Create packages/dependency-installer/ structure following packages/linting/ pattern
  > - Define ToolDetector trait for detection abstraction
  > - Implement 4 detector structs (CargoMachete, OpenTofu, Ansible, LXD)
  > - Create DependencyManager to coordinate detectors
  > - Add comprehensive unit tests with mocked commands
  > - Set up tracing for observability
  >
  > ## Key Components
  >
  > **ToolDetector Trait**:
  > ```rust
  > trait ToolDetector {
  >     fn name(&self) -> &str;
  >     fn is_installed(&self) -> Result<bool, DetectionError>;
  > }
  > ```
  >
  > **4 Detector Implementations**:
  > - CargoMacheteDetector - checks `cargo machete --version`
  > - OpenTofuDetector - checks `tofu --version`
  > - AnsibleDetector - checks `ansible --version`
  > - LxdDetector - checks `lxc --version`
  >
  > **DependencyManager**:
  > - Coordinates all detectors
  > - Provides `check_all()` method returning status for all tools
  >
  > ## Acceptance Criteria
  >
  > - Pre-commit checks pass
  > - Package structure follows linting package pattern
  > - ToolDetector trait is well-defined
  > - All 4 detectors are implemented with proper error handling
  > - DependencyManager works correctly
  > - Unit tests cover all detectors with mocked commands
  > - Logging provides clear visibility
  >
  > ## Time Estimate
  >
  > 2-3 hours
  >
  > ## Related Documentation
  >
  > - Full specification: [docs/issues/114-1-1-1-create-detection-logic-package.md](https://github.com/torrust/torrust-tracker-deployer/blob/main/docs/issues/114-1-1-1-create-detection-logic-package.md)
  > - Linting package reference: packages/linting/
  > - Error handling guide: docs/contributing/error-handling.md</issue_description>
  >
  > ## Comments on the Issue (you are @copilot in this section)
  >
  > <comments>
  > </comments>
  >

  </details>

  - Fixes #114

  <!-- START COPILOT CODING AGENT TIPS -->
  ---

  💬 We'd love your input! Share your thoughts on Copilot coding agent in our [2 minute survey](https://gh.io/copilot-coding-agent-survey).

ACKs for top commit:
  josecelano:
    ACK eaa0acc

Tree-SHA512: 10f9a1163fa41a5690af3eb6c93fcba05e41103dcb475b83421dd16c3459f9cb427c6b6ceb99f5edc65d793063981b402c11fec9a4696bd4e11df41aca5a33ee

Author: josecelano

Cargo.toml

@@ -1,6 +1,7 @@
 [workspace]
 members = [
   "packages/linting",
+  "packages/dependency-installer",
 ]
 resolver = "2"
 

packages/dependency-installer/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "torrust-dependency-installer"
+version = "0.1.0"
+edition = "2021"
+description = "Dependency detection and installation utilities for the Torrust Tracker Deployer project"
+license = "MIT"
+
+[lib]
+name = "torrust_dependency_installer"
+path = "src/lib.rs"
+
+[dependencies]
+thiserror = "1.0"
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = [ "env-filter" ] }

packages/dependency-installer/README.md

@@ -0,0 +1,77 @@
+# Torrust Dependency Installer Package
+
+This package provides dependency detection and installation utilities for the Torrust Tracker Deployer project.
+
+## Features
+
+- **Tool Detection**: Check if required development tools are installed
+- **Extensible**: Easy to add new tool detectors
+- **Logging**: Built-in tracing support for observability
+- **Error Handling**: Clear, actionable error messages
+
+## Required Tools
+
+This package can detect the following development dependencies:
+
+- **cargo-machete** - Detects unused Rust dependencies
+- **OpenTofu** - Infrastructure provisioning tool
+- **Ansible** - Configuration management tool
+- **LXD** - VM-based testing infrastructure
+
+## Usage
+
+### Checking Dependencies
+
+```rust
+use torrust_dependency_installer::DependencyManager;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let manager = DependencyManager::new();
+    
+    // Check all dependencies
+    let results = manager.check_all()?;
+    
+    for result in results {
+        println!("{}: {}", result.tool, if result.installed { "✓" } else { "✗" });
+    }
+    
+    Ok(())
+}
+```
+
+### Using Individual Detectors
+
+```rust
+use torrust_dependency_installer::{ToolDetector, OpenTofuDetector};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let detector = OpenTofuDetector;
+    
+    if detector.is_installed()? {
+        println!("{} is installed", detector.name());
+    } else {
+        println!("{} is not installed", detector.name());
+    }
+    
+    Ok(())
+}
+```
+
+## Adding to Your Project
+
+Add to your `Cargo.toml`:
+
+```toml
+[dependencies]
+torrust-dependency-installer = { path = "path/to/torrust-dependency-installer" }
+```
+
+Or if using in a workspace:
+
+```toml
+[workspace]
+members = ["packages/torrust-dependency-installer"]
+
+[dependencies]
+torrust-dependency-installer = { path = "packages/torrust-dependency-installer" }
+```

packages/dependency-installer/examples/check_dependencies.rs

@@ -0,0 +1,43 @@
+//! Example: Check all development dependencies
+//!
+//! This example demonstrates how to use the dependency installer package
+//! to check if all required development dependencies are installed.
+//!
+//! Run with: `cargo run --example check_dependencies`
+
+use torrust_dependency_installer::{init_tracing, DependencyManager};
+
+fn main() {
+    // Initialize tracing for structured logging
+    init_tracing();
+
+    println!("Checking development dependencies...\n");
+
+    // Create dependency manager
+    let manager = DependencyManager::new();
+
+    // Check all dependencies
+    match manager.check_all() {
+        Ok(results) => {
+            println!("Dependency Status:");
+            println!("{}", "=".repeat(40));
+
+            for result in &results {
+                let status = if result.installed { "✓" } else { "✗" };
+                let status_text = if result.installed {
+                    "Installed"
+                } else {
+                    "Not Installed"
+                };
+
+                println!("{} {:20} {}", status, result.tool, status_text);
+            }
+
+            println!("\n{} dependencies checked", results.len());
+        }
+        Err(e) => {
+            eprintln!("Error checking dependencies: {e}");
+            std::process::exit(1);
+        }
+    }
+}

packages/dependency-installer/src/command.rs

@@ -0,0 +1,82 @@
+use std::process::Command;
+
+use crate::errors::CommandError;
+
+/// Check if a command exists in the system PATH
+///
+/// # Platform Support
+///
+/// Currently uses the `which` command on Unix-like systems. Windows support
+/// would require using `where` command or a different approach.
+///
+/// # Examples
+///
+/// ```rust
+/// use torrust_dependency_installer::command::command_exists;
+///
+/// // Check if 'cargo' is installed
+/// let exists = command_exists("cargo").unwrap();
+/// assert!(exists);
+/// ```
+///
+/// # Errors
+///
+/// Returns an error if the 'which' command fails to execute
+pub fn command_exists(command: &str) -> Result<bool, CommandError> {
+    // Use 'which' on Unix-like systems to check if command exists
+    // Note: This is Unix-specific. For Windows support, use 'where' command.
+    let output =
+        Command::new("which")
+            .arg(command)
+            .output()
+            .map_err(|e| CommandError::ExecutionFailed {
+                command: format!("which {command}"),
+                source: e,
+            })?;
+
+    Ok(output.status.success())
+}
+
+/// Execute a command and return its stdout as a string
+///
+/// # Examples
+///
+/// ```rust,no_run
+/// use torrust_dependency_installer::command::execute_command;
+///
+/// // Get cargo version
+/// let version = execute_command("cargo", &["--version"]).unwrap();
+/// println!("Cargo version: {}", version);
+/// ```
+///
+/// # Errors
+///
+/// Returns an error if the command is not found or fails to execute
+pub fn execute_command(command: &str, args: &[&str]) -> Result<String, CommandError> {
+    let output = Command::new(command).args(args).output().map_err(|e| {
+        if e.kind() == std::io::ErrorKind::NotFound {
+            CommandError::CommandNotFound {
+                command: command.to_string(),
+            }
+        } else {
+            CommandError::ExecutionFailed {
+                command: format!("{command} {}", args.join(" ")),
+                source: e,
+            }
+        }
+    })?;
+
+    if !output.status.success() {
+        return Err(CommandError::ExecutionFailed {
+            command: format!("{command} {}", args.join(" ")),
+            source: std::io::Error::other(format!("Command exited with status: {}", output.status)),
+        });
+    }
+
+    String::from_utf8(output.stdout)
+        .map(|s| s.trim().to_string())
+        .map_err(|e| CommandError::ExecutionFailed {
+            command: format!("{command} {}", args.join(" ")),
+            source: std::io::Error::new(std::io::ErrorKind::InvalidData, e),
+        })
+}

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

@@ -0,0 +1,31 @@
+use tracing::info;
+
+use crate::command::command_exists;
+use crate::detector::ToolDetector;
+use crate::errors::DetectionError;
+
+/// Detector for `Ansible` tool
+pub struct AnsibleDetector;
+
+impl ToolDetector for AnsibleDetector {
+    fn name(&self) -> &'static str {
+        "Ansible"
+    }
+
+    fn is_installed(&self) -> Result<bool, DetectionError> {
+        info!(tool = "ansible", "Checking if Ansible is installed");
+
+        let installed = command_exists("ansible").map_err(|e| DetectionError::DetectionFailed {
+            tool: self.name().to_string(),
+            source: std::io::Error::other(e.to_string()),
+        })?;
+
+        if installed {
+            info!(tool = "ansible", "Ansible is installed");
+        } else {
+            info!(tool = "ansible", "Ansible is not installed");
+        }
+
+        Ok(installed)
+    }
+}

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

@@ -0,0 +1,35 @@
+use tracing::info;
+
+use crate::command::command_exists;
+use crate::detector::ToolDetector;
+use crate::errors::DetectionError;
+
+/// Detector for `cargo-machete` tool
+pub struct CargoMacheteDetector;
+
+impl ToolDetector for CargoMacheteDetector {
+    fn name(&self) -> &'static str {
+        "cargo-machete"
+    }
+
+    fn is_installed(&self) -> Result<bool, DetectionError> {
+        info!(
+            tool = "cargo-machete",
+            "Checking if cargo-machete is installed"
+        );
+
+        let installed =
+            command_exists("cargo-machete").map_err(|e| DetectionError::DetectionFailed {
+                tool: self.name().to_string(),
+                source: std::io::Error::other(e.to_string()),
+            })?;
+
+        if installed {
+            info!(tool = "cargo-machete", "cargo-machete is installed");
+        } else {
+            info!(tool = "cargo-machete", "cargo-machete is not installed");
+        }
+
+        Ok(installed)
+    }
+}

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

@@ -0,0 +1,32 @@
+use tracing::info;
+
+use crate::command::command_exists;
+use crate::detector::ToolDetector;
+use crate::errors::DetectionError;
+
+/// Detector for `LXD` tool
+pub struct LxdDetector;
+
+impl ToolDetector for LxdDetector {
+    fn name(&self) -> &'static str {
+        "LXD"
+    }
+
+    fn is_installed(&self) -> Result<bool, DetectionError> {
+        info!(tool = "lxd", "Checking if LXD is installed");
+
+        // Check for 'lxc' command (LXD client)
+        let installed = command_exists("lxc").map_err(|e| DetectionError::DetectionFailed {
+            tool: self.name().to_string(),
+            source: std::io::Error::other(e.to_string()),
+        })?;
+
+        if installed {
+            info!(tool = "lxd", "LXD is installed");
+        } else {
+            info!(tool = "lxd", "LXD is not installed");
+        }
+
+        Ok(installed)
+    }
+}

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

@@ -0,0 +1,29 @@
+pub mod ansible;
+pub mod cargo_machete;
+pub mod lxd;
+pub mod opentofu;
+
+use crate::errors::DetectionError;
+
+pub use ansible::AnsibleDetector;
+pub use cargo_machete::CargoMacheteDetector;
+pub use lxd::LxdDetector;
+pub use opentofu::OpenTofuDetector;
+
+/// Trait for detecting if a tool is installed
+pub trait ToolDetector {
+    /// Get the tool name for display purposes
+    fn name(&self) -> &'static str;
+
+    /// Check if the tool is already installed
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the detection process fails
+    fn is_installed(&self) -> Result<bool, DetectionError>;
+
+    /// Get the required version (if applicable)
+    fn required_version(&self) -> Option<&str> {
+        None // Default implementation
+    }
+}

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

@@ -0,0 +1,31 @@
+use tracing::info;
+
+use crate::command::command_exists;
+use crate::detector::ToolDetector;
+use crate::errors::DetectionError;
+
+/// Detector for `OpenTofu` tool
+pub struct OpenTofuDetector;
+
+impl ToolDetector for OpenTofuDetector {
+    fn name(&self) -> &'static str {
+        "OpenTofu"
+    }
+
+    fn is_installed(&self) -> Result<bool, DetectionError> {
+        info!(tool = "opentofu", "Checking if OpenTofu is installed");
+
+        let installed = command_exists("tofu").map_err(|e| DetectionError::DetectionFailed {
+            tool: self.name().to_string(),
+            source: std::io::Error::other(e.to_string()),
+        })?;
+
+        if installed {
+            info!(tool = "opentofu", "OpenTofu is installed");
+        } else {
+            info!(tool = "opentofu", "OpenTofu is not installed");
+        }
+
+        Ok(installed)
+    }
+}