feat: add Console abstraction for standard I/O

Abstract standard input/output to infrastructure layer.
Replace direct println!, eprintln!, io::stdin(), io::stdout() usage
in CLI commands with Console trait.

Implementation:
- RealConsole: uses actual standard I/O (println!, eprintln!, etc.)
- MockConsole: stores output in vectors for testing (test-mocks feature)

Console trait methods:
- print, println, eprintln: output methods
- read_line: input method
- flush: flush stdout

Files updated:
- All CLI command files (repo, game, stats, history, export, trending)
- Replace all standard I/O calls with Console abstraction

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

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

Author: unhappychoice

src/infrastructure/console.rs

@@ -0,0 +1,138 @@
+use crate::Result;
+
+/// Trait for console I/O abstraction
+pub trait Console {
+    fn print(&self, message: &str) -> Result<()>;
+    fn println(&self, message: &str) -> Result<()>;
+    fn eprintln(&self, message: &str) -> Result<()>;
+    fn read_line(&self, buffer: &mut String) -> Result<()>;
+    fn flush(&self) -> Result<()>;
+}
+
+#[cfg(not(feature = "test-mocks"))]
+mod real_impl {
+    use super::*;
+    use std::io::{self, Write};
+
+    #[derive(Debug, Clone)]
+    pub struct RealConsole;
+
+    impl RealConsole {
+        pub fn new() -> Self {
+            Self
+        }
+    }
+
+    impl Default for RealConsole {
+        fn default() -> Self {
+            Self::new()
+        }
+    }
+
+    impl Console for RealConsole {
+        fn print(&self, message: &str) -> Result<()> {
+            print!("{}", message);
+            Ok(())
+        }
+
+        fn println(&self, message: &str) -> Result<()> {
+            println!("{}", message);
+            Ok(())
+        }
+
+        fn eprintln(&self, message: &str) -> Result<()> {
+            eprintln!("{}", message);
+            Ok(())
+        }
+
+        fn read_line(&self, buffer: &mut String) -> Result<()> {
+            io::stdin().read_line(buffer)?;
+            Ok(())
+        }
+
+        fn flush(&self) -> Result<()> {
+            io::stdout().flush()?;
+            Ok(())
+        }
+    }
+}
+
+#[cfg(feature = "test-mocks")]
+mod mock_impl {
+    use super::*;
+    use std::cell::RefCell;
+
+    #[derive(Debug, Clone)]
+    pub struct MockConsole {
+        pub output: RefCell<Vec<String>>,
+        pub error_output: RefCell<Vec<String>>,
+        pub input_lines: RefCell<Vec<String>>,
+    }
+
+    impl MockConsole {
+        pub fn new() -> Self {
+            Self {
+                output: RefCell::new(Vec::new()),
+                error_output: RefCell::new(Vec::new()),
+                input_lines: RefCell::new(Vec::new()),
+            }
+        }
+
+        pub fn set_input_lines(&self, lines: Vec<String>) {
+            *self.input_lines.borrow_mut() = lines;
+        }
+
+        pub fn get_output(&self) -> Vec<String> {
+            self.output.borrow().clone()
+        }
+
+        pub fn get_error_output(&self) -> Vec<String> {
+            self.error_output.borrow().clone()
+        }
+    }
+
+    impl Default for MockConsole {
+        fn default() -> Self {
+            Self::new()
+        }
+    }
+
+    impl Console for MockConsole {
+        fn print(&self, message: &str) -> Result<()> {
+            self.output.borrow_mut().push(message.to_string());
+            Ok(())
+        }
+
+        fn println(&self, message: &str) -> Result<()> {
+            self.output.borrow_mut().push(message.to_string());
+            Ok(())
+        }
+
+        fn eprintln(&self, message: &str) -> Result<()> {
+            self.error_output.borrow_mut().push(message.to_string());
+            Ok(())
+        }
+
+        fn read_line(&self, buffer: &mut String) -> Result<()> {
+            let mut input_lines = self.input_lines.borrow_mut();
+            if let Some(line) = input_lines.first() {
+                buffer.push_str(line);
+                if !line.ends_with('\n') {
+                    buffer.push('\n');
+                }
+                input_lines.remove(0);
+            }
+            Ok(())
+        }
+
+        fn flush(&self) -> Result<()> {
+            Ok(())
+        }
+    }
+}
+
+#[cfg(not(feature = "test-mocks"))]
+pub use real_impl::RealConsole as ConsoleImpl;
+
+#[cfg(feature = "test-mocks")]
+pub use mock_impl::MockConsole as ConsoleImpl;

src/infrastructure/mod.rs

@@ -1,4 +1,5 @@
 pub mod browser;
+pub mod console;
 pub mod database;
 pub mod git;
 pub mod http;

src/presentation/cli/commands/export.rs

@@ -1,12 +1,14 @@
+use crate::infrastructure::console::{Console, ConsoleImpl};
 use crate::Result;
 use std::path::PathBuf;
 
 pub fn run_export(format: String, output: Option<PathBuf>) -> Result<()> {
-    eprintln!("❌ Export command is not yet implemented");
-    eprintln!("💡 Requested format: {}", format);
+    let console = ConsoleImpl::new();
+    console.eprintln("❌ Export command is not yet implemented")?;
+    console.eprintln(&format!("💡 Requested format: {}", format))?;
     if let Some(path) = output {
-        eprintln!("💡 Requested output: {}", path.display());
+        console.eprintln(&format!("💡 Requested output: {}", path.display()))?;
     }
-    eprintln!("💡 This feature is planned for a future release");
+    console.eprintln("💡 This feature is planned for a future release")?;
     std::process::exit(1);
 }

src/presentation/cli/commands/game.rs

@@ -3,6 +3,7 @@ use crate::domain::models::ExtractionOptions;
 use crate::domain::models::Languages;
 use crate::domain::services::theme_manager::ThemeManager;
 use crate::domain::services::version_service::VersionService;
+use crate::infrastructure::console::{Console, ConsoleImpl};
 use crate::infrastructure::logging;
 use crate::presentation::cli::args::Cli;
 use crate::presentation::game::{GameData, SessionManager};
@@ -16,6 +17,8 @@ use std::sync::{Arc, Mutex};
 pub fn run_game_session(cli: Cli) -> Result<()> {
     log::info!("Starting GitType game session");
 
+    let console = ConsoleImpl::new();
+
     // Create single EventBus instance for the entire application
     let event_bus = EventBus::new();
 
@@ -47,8 +50,11 @@ pub fn run_game_session(cli: Cli) -> Result<()> {
     // Initialize theme manager
     if let Err(e) = ThemeManager::init() {
         log::warn!("Failed to initialize theme manager: {}", e);
-        eprintln!("⚠️ Warning: Failed to load theme configuration: {}", e);
-        eprintln!("   Using default theme.");
+        console.eprintln(&format!(
+            "⚠️ Warning: Failed to load theme configuration: {}",
+            e
+        ))?;
+        console.eprintln("   Using default theme.")?;
     }
 
     // Session repository will be initialized in DatabaseInitStep during loading screen
@@ -57,16 +63,16 @@ pub fn run_game_session(cli: Cli) -> Result<()> {
 
     if let Some(langs) = cli.langs {
         if let Err(unsupported_langs) = Languages::validate_languages(&langs) {
-            eprintln!(
+            console.eprintln(&format!(
                 "❌ Unsupported language(s): {}",
                 unsupported_langs.join(", ")
-            );
-            eprintln!("💡 Supported languages:");
+            ))?;
+            console.eprintln("💡 Supported languages:")?;
             let supported = Languages::get_supported_languages();
             let mut supported_display = supported.clone();
             supported_display.dedup();
             for chunk in supported_display.chunks(6) {
-                eprintln!("   {}", chunk.join(", "));
+                console.eprintln(&format!("   {}", chunk.join(", ")))?;
             }
             std::process::exit(1);
         }
@@ -127,108 +133,113 @@ pub fn run_game_session(cli: Cli) -> Result<()> {
         }
         Err(e) => {
             log::error!("Game session failed with error: {}", e);
-            handle_game_error(e)?;
+            handle_game_error(&console, e)?;
         }
     }
 
     Ok(())
 }
 
-fn handle_game_error(e: GitTypeError) -> Result<()> {
+fn handle_game_error(console: &impl Console, e: GitTypeError) -> Result<()> {
     // Log the error details for debugging before handling user-friendly output
     logging::log_error_to_file(&e);
 
     match e {
         GitTypeError::NoSupportedFiles => {
-            eprintln!("❌ No code chunks found in the repository");
-            eprintln!("💡 Try:");
-            eprintln!("   • Using a different repository path");
-            eprintln!("   • Adjusting --langs filter (e.g., --langs rust,python)");
+            console.eprintln("❌ No code chunks found in the repository")?;
+            console.eprintln("💡 Try:")?;
+            console.eprintln("   • Using a different repository path")?;
+            console.eprintln("   • Adjusting --langs filter (e.g., --langs rust,python)")?;
             std::process::exit(1);
         }
         GitTypeError::RepositoryNotFound(path) => {
-            eprintln!("❌ Repository not found at path: {}", path.display());
-            eprintln!("💡 Ensure the path exists and is a valid repository");
+            console.eprintln(&format!(
+                "❌ Repository not found at path: {}",
+                path.display()
+            ))?;
+            console.eprintln("💡 Ensure the path exists and is a valid repository")?;
             std::process::exit(1);
         }
         GitTypeError::RepositoryCloneError(git_error) => {
-            eprintln!("❌ Failed to clone repository: {}", git_error);
-            eprintln!("💡 Check:");
-            eprintln!("   • Repository URL is correct");
-            eprintln!("   • You have access to the repository");
-            eprintln!("   • Internet connection is available");
+            console.eprintln(&format!("❌ Failed to clone repository: {}", git_error))?;
+            console.eprintln("💡 Check:")?;
+            console.eprintln("   • Repository URL is correct")?;
+            console.eprintln("   • You have access to the repository")?;
+            console.eprintln("   • Internet connection is available")?;
             std::process::exit(1);
         }
         GitTypeError::ExtractionFailed(msg) => {
-            eprintln!("❌ Code extraction failed: {}", msg);
-            eprintln!("💡 Try using different --langs filter");
+            console.eprintln(&format!("❌ Code extraction failed: {}", msg))?;
+            console.eprintln("💡 Try using different --langs filter")?;
             std::process::exit(1);
         }
         GitTypeError::InvalidRepositoryFormat(msg) => {
-            eprintln!("❌ Invalid repository format: {}", msg);
-            eprintln!("💡 Supported formats:");
-            eprintln!("   • owner/repo");
-            eprintln!("   • https://github.com/owner/repo");
-            eprintln!("   • git@github.com:owner/repo.git");
+            console.eprintln(&format!("❌ Invalid repository format: {}", msg))?;
+            console.eprintln("💡 Supported formats:")?;
+            console.eprintln("   • owner/repo")?;
+            console.eprintln("   • https://github.com/owner/repo")?;
+            console.eprintln("   • git@github.com:owner/repo.git")?;
             std::process::exit(1);
         }
         GitTypeError::IoError(io_error) => {
-            eprintln!("❌ IO error: {}", io_error);
+            console.eprintln(&format!("❌ IO error: {}", io_error))?;
             std::process::exit(1);
         }
         GitTypeError::DatabaseError(db_error) => {
-            eprintln!("❌ Database error: {}", db_error);
+            console.eprintln(&format!("❌ Database error: {}", db_error))?;
             std::process::exit(1);
         }
         GitTypeError::GlobPatternError(glob_error) => {
-            eprintln!("❌ Invalid glob pattern: {}", glob_error);
-            eprintln!("💡 Check your glob patterns in ExtractionOptions");
+            console.eprintln(&format!("❌ Invalid glob pattern: {}", glob_error))?;
+            console.eprintln("💡 Check your glob patterns in ExtractionOptions")?;
             std::process::exit(1);
         }
         GitTypeError::SerializationError(json_error) => {
-            eprintln!("❌ Serialization error: {}", json_error);
+            console.eprintln(&format!("❌ Serialization error: {}", json_error))?;
             std::process::exit(1);
         }
         GitTypeError::TerminalError(msg) => {
-            eprintln!("❌ Terminal error: {}", msg);
+            console.eprintln(&format!("❌ Terminal error: {}", msg))?;
             if msg.contains("No such device or address") {
-                eprintln!("💡 This error often occurs in WSL or SSH environments where terminal features are limited.");
-                eprintln!("   Try running GitType in a native terminal or GUI terminal emulator.");
+                console.eprintln("💡 This error often occurs in WSL or SSH environments where terminal features are limited.")?;
+                console.eprintln(
+                    "   Try running GitType in a native terminal or GUI terminal emulator.",
+                )?;
             }
             std::process::exit(1);
         }
         GitTypeError::WalkDirError(walk_error) => {
-            eprintln!("❌ Directory walk error: {}", walk_error);
-            eprintln!("💡 Check directory permissions and try again");
+            console.eprintln(&format!("❌ Directory walk error: {}", walk_error))?;
+            console.eprintln("💡 Check directory permissions and try again")?;
             std::process::exit(1);
         }
         GitTypeError::TreeSitterLanguageError(lang_error) => {
-            eprintln!("❌ Language parsing error: {}", lang_error);
-            eprintln!("💡 This might be caused by unsupported language features");
+            console.eprintln(&format!("❌ Language parsing error: {}", lang_error))?;
+            console.eprintln("💡 This might be caused by unsupported language features")?;
             std::process::exit(1);
         }
         GitTypeError::PanicError(msg) => {
-            eprintln!("💥 Application panic occurred: {}", msg);
-            eprintln!("💡 This indicates an unexpected error. Please report this issue.");
+            console.eprintln(&format!("💥 Application panic occurred: {}", msg))?;
+            console.eprintln("💡 This indicates an unexpected error. Please report this issue.")?;
             std::process::exit(1);
         }
         GitTypeError::HttpError(http_error) => {
-            eprintln!("❌ HTTP request failed: {}", http_error);
-            eprintln!("💡 Check your internet connection and try again");
+            console.eprintln(&format!("❌ HTTP request failed: {}", http_error))?;
+            console.eprintln("💡 Check your internet connection and try again")?;
             std::process::exit(1);
         }
         GitTypeError::ApiError(msg) => {
-            eprintln!("❌ API error: {}", msg);
-            eprintln!("💡 The service may be temporarily unavailable");
+            console.eprintln(&format!("❌ API error: {}", msg))?;
+            console.eprintln("💡 The service may be temporarily unavailable")?;
             std::process::exit(1);
         }
         GitTypeError::ValidationError(msg) => {
-            eprintln!("❌ {}", msg);
+            console.eprintln(&format!("❌ {}", msg))?;
             std::process::exit(1);
         }
         GitTypeError::ScreenInitializationError(msg) => {
-            eprintln!("❌ Screen initialization error: {}", msg);
-            eprintln!("💡 This is an internal error. Please report this issue.");
+            console.eprintln(&format!("❌ Screen initialization error: {}", msg))?;
+            console.eprintln("💡 This is an internal error. Please report this issue.")?;
             std::process::exit(1);
         }
     }

src/presentation/cli/commands/history.rs

@@ -1,7 +1,9 @@
+use crate::infrastructure::console::{Console, ConsoleImpl};
 use crate::Result;
 
 pub fn run_history() -> Result<()> {
-    eprintln!("❌ History command is not yet implemented");
-    eprintln!("💡 This feature is planned for a future release");
+    let console = ConsoleImpl::new();
+    console.eprintln("❌ History command is not yet implemented")?;
+    console.eprintln("💡 This feature is planned for a future release")?;
     std::process::exit(1);
 }

src/presentation/cli/commands/stats.rs

@@ -1,7 +1,9 @@
+use crate::infrastructure::console::{Console, ConsoleImpl};
 use crate::Result;
 
 pub fn run_stats() -> Result<()> {
-    eprintln!("❌ Stats command is not yet implemented");
-    eprintln!("💡 This feature is planned for a future release");
+    let console = ConsoleImpl::new();
+    console.eprintln("❌ Stats command is not yet implemented")?;
+    console.eprintln("💡 This feature is planned for a future release")?;
     std::process::exit(1);
 }