Merge #82: Eliminate direct console output bypassing UserOutput abstraction

c9e6f07 fix: use steps() method with multi-line strings for numbered list (copilot-swe-agent[bot])
6a2902d fix: use info_block for numbered list with sub-items (copilot-swe-agent[bot])
3728e8f feat: eliminate direct console output bypassing UserOutput (copilot-swe-agent[bot])
6309517 Initial plan (copilot-swe-agent[bot])

Pull request description:

  The presentation layer directly called `println!()` and `eprintln!()`, bypassing the `UserOutput` service abstraction. This violated the architecture, prevented verbosity control, and made output untestable.

  ## Changes

  **Extended UserOutput API** with three new methods:
  - `blank_line()` - spacing between output sections
  - `steps()` - automatic numbering for sequential instructions
  - `info_block()` - multi-line information blocks

  All methods respect verbosity levels and route output to appropriate channels (stderr for operational messages, stdout for results).

  **Refactored presentation layer** to eliminate all direct console calls:
  - `create/subcommands/template.rs` - replaced 11 `println!()` calls with `steps()` and `blank_line()`
  - `commands/mod.rs` - replaced 3 `eprintln!()` calls in `handle_error()` with UserOutput methods

  ## Example

  Before:
  ```rust
  println!();
  println!("Next steps:");
  println!("1. Edit the template file...");
  ```

  After:
  ```rust
  output.blank_line();
  output.steps("Next steps:", &[
      "Edit the template file...",
      "Review default values...",
  ]);
  ```

  Output format preserved. All messages now respect verbosity levels and can be tested/redirected.

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

  <details>

  <summary>Original prompt</summary>

  >
  > ----
  >
  > *This section details on the original issue you should resolve*
  >
  > <issue_title>Eliminate Direct Console Output Bypassing UserOutput</issue_title>
  > <issue_description>**Parent Issue**: #63
  > **Type**: 🎯 Quick Win
  > **Impact**: 🟢🟢🟢 High
  > **Effort**: 🔵🔵 Medium
  > **Priority**: P0
  > **Depends On**: #66 (Proposal 3)
  >
  > ## Problem
  >
  > The presentation layer directly calls `println!()` and other console output macros, bypassing the `UserOutput` service abstraction:
  >
  > ```rust
  > fn display_success_message(output: &mut UserOutput, output_path: &Path) {
  >     output.success(&format!("Configuration template generated: {}", output_path.display()));
  >
  >     println!();  // ❌ Bypasses UserOutput
  >     println!("Next steps:");  // ❌ Bypasses UserOutput
  >     println!("1. Edit the template file...");  // ❌ Bypasses UserOutput
  >     // More println! calls...
  > }
  > ```
  >
  > **Why this is a problem:**
  > - Violates abstraction - `UserOutput` should centralize all user-facing output
  > - No verbosity control - can't suppress based on verbosity level
  > - Hard to test - can't capture or verify output
  > - No output redirection - can't redirect to files or alternative formats
  >
  > ## Proposed Solution
  >
  > Extend `UserOutput` with structured message methods:
  >
  > ```rust
  > impl UserOutput {
  >     /// Display a multi-line information block
  >     pub fn info_block(&mut self, title: &str, lines: &[&str]) {
  >         if self.verbosity >= VerbosityLevel::Normal {
  >             println!();
  >             println!("{}", title);
  >             for line in lines {
  >                 println!("{}", line);
  >             }
  >         }
  >     }
  >
  >     /// Display a numbered list of steps
  >     pub fn steps(&mut self, title: &str, steps: &[&str]) {
  >         if self.verbosity >= VerbosityLevel::Normal {
  >             println!();
  >             println!("{}", title);
  >             for (idx, step) in steps.iter().enumerate() {
  >                 println!("{}. {}", idx + 1, step);
  >             }
  >         }
  >     }
  >
  >     /// Display a blank line (for spacing)
  >     pub fn blank_line(&mut self) {
  >         if self.verbosity >= VerbosityLevel::Normal {
  >             println!();
  >         }
  >     }
  > }
  > ```
  >
  > Then refactor handlers:
  > ```rust
  > fn display_success_message(output: &mut UserOutput, output_path: &Path) {
  >     output.success(&format!("Configuration template generated: {}", output_path.display()));
  >     output.blank_line();
  >     output.steps("Next steps:", &[
  >         "Edit the template file and replace placeholder values...",
  >         "Review default values...",
  >         "Create the environment...",
  >     ]);
  > }
  > ```
  >
  > ## Benefits
  >
  > - ✅ All output goes through `UserOutput` service
  > - ✅ Consistent formatting and verbosity control
  > - ✅ Testable output (can verify messages in tests)
  > - ✅ Supports future output redirection (files, JSON, etc.)
  > - ✅ Easy to change output format globally
  > - ✅ Aligns with project architecture principles
  >
  > ## Implementation Checklist
  >
  > **Phase 1: Extend UserOutput API**
  > - [ ] Add `blank_line()` method to `UserOutput`
  > - [ ] Add `steps()` method for numbered lists
  > - [ ] Add `info_block()` method for multi-line info blocks
  > - [ ] Add tests for new methods
  > - [ ] Document new methods with examples
  >
  > **Phase 2: Refactor template subcommand**
  > - [ ] Identify all `println!()` calls in `create/subcommands/template.rs`
  > - [ ] Replace with appropriate `UserOutput` methods
  > - [ ] Verify output format is preserved
  > - [ ] Update tests to verify output
  >
  > **Phase 3: Audit all presentation layer files**
  > - [ ] Search `src/presentation/` for `println!()`, `print!()`, `eprintln!()`, `eprint!()`
  > - [ ] Create inventory of direct output calls
  > - [ ] Replace each with appropriate `UserOutput` method
  > - [ ] Add new `UserOutput` methods as needed
  >
  > **Phase 4: Validation**
  > - [ ] Run all tests to ensure output is correct
  > - [ ] Manual testing with different verbosity levels
  > - [ ] Verify output redirection works (if implemented)
  > - [ ] Run linter and fix issues
  >
  > ## Acceptance Criteria
  >
  > - [ ] `UserOutput` has methods for all output patterns used
  > - [ ] No direct `println!()`, `print!()`, `eprintln!()`, or `eprint!()` calls in `src/presentation/`
  > - [ ] All output respects verbosity levels
  > - [ ] Output format is preserved or improved
  > - [ ] All tests pass: `cargo test presentation`
  > - [ ] Pre-commit checks pass: `./scripts/pre-commit.sh`
  > - [ ] Code follows project conventions
  >
  > ## Related Documentation
  >
  > - [Refactor Plan](https://github.com/torrust/torrust-tracker-deployer/blob/main/docs/refactors/plans/presentation-commands-cleanup.md)</issue_description>
  >
  > ## Comments on the Issue (you are @copilot in this section)
  >
  > <comments>
  > </comments>
  >

  </details>

  - Fixes #68

  <!-- 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 c9e6f07

Tree-SHA512: 44202c950a5aa344a24844dab91e6cf11803f720d85345170fb3ee84c461e2ee29097665d817aae2406fa7a709761ef00955ef85f3284ecf55954e02c31676a0

Author: josecelano

src/presentation/commands/create/subcommands/template.rs

@@ -53,19 +53,19 @@ pub fn handle_template_generation(output_path: &Path) -> Result<(), CreateSubcom
         "Configuration template generated: {}",
         output_path.display()
     ));
-    println!();
-    println!("Next steps:");
-    println!("1. Edit the template file and replace placeholder values:");
-    println!("   - REPLACE_WITH_ENVIRONMENT_NAME: Choose a unique environment name (e.g., 'dev', 'staging')");
-    println!("   - REPLACE_WITH_SSH_PRIVATE_KEY_PATH: Path to your SSH private key");
-    println!("   - REPLACE_WITH_SSH_PUBLIC_KEY_PATH: Path to your SSH public key");
-    println!("2. Review default values:");
-    println!("   - username: 'torrust' (can be changed if needed)");
-    println!("   - port: 22 (standard SSH port)");
-    println!("3. Create the environment:");
-    println!(
-        "   torrust-tracker-deployer create environment --env-file {}",
-        output_path.display()
+
+    output.blank_line();
+
+    output.steps(
+        "Next steps:",
+        &[
+            "Edit the template file and replace placeholder values:\n   - REPLACE_WITH_ENVIRONMENT_NAME: Choose a unique environment name (e.g., 'dev', 'staging')\n   - REPLACE_WITH_SSH_PRIVATE_KEY_PATH: Path to your SSH private key\n   - REPLACE_WITH_SSH_PUBLIC_KEY_PATH: Path to your SSH public key",
+            "Review default values:\n   - username: 'torrust' (can be changed if needed)\n   - port: 22 (standard SSH port)",
+            &format!(
+                "Create the environment:\n   torrust-tracker-deployer create environment --env-file {}",
+                output_path.display()
+            ),
+        ],
     );
 
     Ok(())

src/presentation/commands/mod.rs

@@ -119,7 +119,12 @@ pub fn execute(command: Commands, working_dir: &std::path::Path) -> Result<(), C
 /// # }
 /// ```
 pub fn handle_error(error: &CommandError) {
-    eprintln!("Error: {error}");
-    eprintln!("\nFor detailed troubleshooting:");
-    eprintln!("{}", error.help());
+    use crate::presentation::user_output::{UserOutput, VerbosityLevel};
+
+    let mut output = UserOutput::new(VerbosityLevel::Normal);
+    let help_text = error.help();
+
+    output.error(&format!("{error}"));
+    output.blank_line();
+    output.info_block("For detailed troubleshooting:", &[help_text]);
 }

src/presentation/user_output.rs

@@ -264,6 +264,86 @@ impl UserOutput {
     pub fn data(&mut self, data: &str) {
         writeln!(self.stdout_writer, "{data}").ok();
     }
+
+    /// Display a blank line to stderr (Normal level and above)
+    ///
+    /// Used for spacing between sections of output to improve readability.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use torrust_tracker_deployer_lib::presentation::user_output::{UserOutput, VerbosityLevel};
+    ///
+    /// let mut output = UserOutput::new(VerbosityLevel::Normal);
+    /// output.success("Configuration template generated");
+    /// output.blank_line();
+    /// output.progress("Starting next steps...");
+    /// ```
+    pub fn blank_line(&mut self) {
+        if self.verbosity >= VerbosityLevel::Normal {
+            writeln!(self.stderr_writer).ok();
+        }
+    }
+
+    /// Display a numbered list of steps to stderr (Normal level and above)
+    ///
+    /// Useful for displaying sequential instructions or action items.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use torrust_tracker_deployer_lib::presentation::user_output::{UserOutput, VerbosityLevel};
+    ///
+    /// let mut output = UserOutput::new(VerbosityLevel::Normal);
+    /// output.steps("Next steps:", &[
+    ///     "Edit the configuration file",
+    ///     "Review the settings",
+    ///     "Run the deploy command",
+    /// ]);
+    /// // Output to stderr:
+    /// // Next steps:
+    /// // 1. Edit the configuration file
+    /// // 2. Review the settings
+    /// // 3. Run the deploy command
+    /// ```
+    pub fn steps(&mut self, title: &str, steps: &[&str]) {
+        if self.verbosity >= VerbosityLevel::Normal {
+            writeln!(self.stderr_writer, "{title}").ok();
+            for (idx, step) in steps.iter().enumerate() {
+                writeln!(self.stderr_writer, "{}. {}", idx + 1, step).ok();
+            }
+        }
+    }
+
+    /// Display a multi-line information block to stderr (Normal level and above)
+    ///
+    /// Useful for displaying grouped information or detailed messages.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use torrust_tracker_deployer_lib::presentation::user_output::{UserOutput, VerbosityLevel};
+    ///
+    /// let mut output = UserOutput::new(VerbosityLevel::Normal);
+    /// output.info_block("Configuration options:", &[
+    ///     "  - username: 'torrust' (default)",
+    ///     "  - port: 22 (default SSH port)",
+    ///     "  - key_path: path/to/key",
+    /// ]);
+    /// // Output to stderr:
+    /// // Configuration options:
+    /// //   - username: 'torrust' (default)
+    /// //   - port: 22 (default SSH port)
+    /// //   - key_path: path/to/key
+    /// ```
+    pub fn info_block(&mut self, title: &str, lines: &[&str]) {
+        if self.verbosity >= VerbosityLevel::Normal {
+            writeln!(self.stderr_writer, "{title}").ok();
+            for line in lines {
+                writeln!(self.stderr_writer, "{line}").ok();
+            }
+        }
+    }
 }
 
 #[cfg(test)]
@@ -472,4 +552,101 @@ mod tests {
         assert!(normal >= VerbosityLevel::Normal);
         assert!(normal < VerbosityLevel::Verbose);
     }
+
+    #[test]
+    fn it_should_write_blank_line_to_stderr() {
+        let (mut output, stdout_buf, stderr_buf) = create_test_user_output(VerbosityLevel::Normal);
+
+        output.blank_line();
+
+        // Verify blank line went to stderr
+        let stderr_content = String::from_utf8(stderr_buf.lock().unwrap().clone()).unwrap();
+        assert_eq!(stderr_content, "\n");
+
+        // Verify stdout is empty
+        let stdout_content = String::from_utf8(stdout_buf.lock().unwrap().clone()).unwrap();
+        assert_eq!(stdout_content, "");
+    }
+
+    #[test]
+    fn it_should_not_write_blank_line_at_quiet_level() {
+        let (mut output, _stdout_buf, stderr_buf) = create_test_user_output(VerbosityLevel::Quiet);
+
+        output.blank_line();
+
+        // Verify no output at Quiet level
+        let stderr_content = String::from_utf8(stderr_buf.lock().unwrap().clone()).unwrap();
+        assert_eq!(stderr_content, "");
+    }
+
+    #[test]
+    fn it_should_write_steps_to_stderr() {
+        let (mut output, stdout_buf, stderr_buf) = create_test_user_output(VerbosityLevel::Normal);
+
+        output.steps(
+            "Next steps:",
+            &[
+                "Edit the configuration file",
+                "Review the settings",
+                "Run the deploy command",
+            ],
+        );
+
+        // Verify steps went to stderr with correct formatting
+        let stderr_content = String::from_utf8(stderr_buf.lock().unwrap().clone()).unwrap();
+        assert_eq!(
+            stderr_content,
+            "Next steps:\n1. Edit the configuration file\n2. Review the settings\n3. Run the deploy command\n"
+        );
+
+        // Verify stdout is empty
+        let stdout_content = String::from_utf8(stdout_buf.lock().unwrap().clone()).unwrap();
+        assert_eq!(stdout_content, "");
+    }
+
+    #[test]
+    fn it_should_not_write_steps_at_quiet_level() {
+        let (mut output, _stdout_buf, stderr_buf) = create_test_user_output(VerbosityLevel::Quiet);
+
+        output.steps("Next steps:", &["Step 1", "Step 2"]);
+
+        // Verify no output at Quiet level
+        let stderr_content = String::from_utf8(stderr_buf.lock().unwrap().clone()).unwrap();
+        assert_eq!(stderr_content, "");
+    }
+
+    #[test]
+    fn it_should_write_info_block_to_stderr() {
+        let (mut output, stdout_buf, stderr_buf) = create_test_user_output(VerbosityLevel::Normal);
+
+        output.info_block(
+            "Configuration options:",
+            &[
+                "  - username: 'torrust' (default)",
+                "  - port: 22 (default SSH port)",
+            ],
+        );
+
+        // Verify info block went to stderr
+        let stderr_content = String::from_utf8(stderr_buf.lock().unwrap().clone()).unwrap();
+        assert_eq!(
+            stderr_content,
+            "Configuration options:\n  - username: 'torrust' (default)\n  - port: 22 (default SSH port)\n"
+        );
+
+        // Verify stdout is empty
+        let stdout_content = String::from_utf8(stdout_buf.lock().unwrap().clone()).unwrap();
+        assert_eq!(stdout_content, "");
+    }
+
+    #[test]
+    fn it_should_not_write_info_block_at_quiet_level() {
+        let (mut output, _stdout_buf, stderr_buf) = create_test_user_output(VerbosityLevel::Quiet);
+
+        output.info_block("Info:", &["Line 1", "Line 2"]);
+
+        // Verify no output at Quiet level
+        let stderr_content = String::from_utf8(stderr_buf.lock().unwrap().clone()).unwrap();
+        assert_eq!(stderr_content, "");
+    }
 }