feat: add database initialization and development environment setup

- Add HasDatabase trait for DRY database locking
- Separate development and production database/log paths
- Add DatabaseInitStep for loading screen initialization
- Implement comprehensive logging system with timestamp-based filenames
- Configure development logs in project directory, production in ~/.gittype
- Remove console appender to prevent stdout interference
- Add proper database initialization during application startup

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

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

Author: unhappychoice

src/game/models/loading_steps/database_init_step.rs

@@ -0,0 +1,71 @@
+use super::{ExecutionContext, Step, StepResult, StepType};
+use crate::storage::{Database, SessionRepository};
+use crate::Result;
+use ratatui::style::Color;
+
+#[derive(Debug, Clone)]
+pub struct DatabaseInitStep;
+
+impl Step for DatabaseInitStep {
+    fn step_type(&self) -> StepType {
+        StepType::DatabaseInit
+    }
+    fn step_number(&self) -> usize {
+        1
+    }
+    fn description(&self) -> &str {
+        "Initializing database and session recording"
+    }
+    fn step_name(&self) -> &str {
+        "Database Setup"
+    }
+
+    fn icon(&self, is_current: bool, is_completed: bool) -> (&str, Color) {
+        if is_completed {
+            ("✓", Color::Green)
+        } else if is_current {
+            ("💾", Color::Yellow)
+        } else {
+            ("◦", Color::DarkGray)
+        }
+    }
+
+    fn supports_progress(&self) -> bool {
+        false
+    }
+    fn progress_unit(&self) -> &str {
+        ""
+    }
+
+    fn format_progress(
+        &self,
+        _processed: usize,
+        _total: usize,
+        _progress: f64,
+        _spinner: char,
+    ) -> String {
+        "Initializing database...".to_string()
+    }
+
+    fn execute(&self, _context: &mut ExecutionContext) -> Result<StepResult> {
+        log::info!("DatabaseInitStep: Starting database initialization");
+
+        // Initialize database with migrations
+        let database = Database::new()?;
+        database.init()?;
+        log::info!("DatabaseInitStep: Database initialized successfully");
+
+        // Initialize global session repository
+        if let Err(e) = SessionRepository::initialize_global() {
+            log::error!(
+                "DatabaseInitStep: Failed to initialize global session repository: {}",
+                e
+            );
+            return Err(e);
+        } else {
+            log::info!("DatabaseInitStep: Global session repository initialized successfully");
+        }
+
+        Ok(StepResult::Skipped)
+    }
+}

src/logging.rs

@@ -0,0 +1,117 @@
+use crate::{error::GitTypeError, Result};
+use chrono;
+use log4rs::{
+    append::{console::ConsoleAppender, file::FileAppender},
+    config::{Appender, Config, Root},
+    encode::pattern::PatternEncoder,
+};
+use std::path::PathBuf;
+
+pub fn setup_logging() -> Result<()> {
+    let log_dir = get_log_directory()?;
+    std::fs::create_dir_all(&log_dir)?;
+
+    // Create timestamp-based log filename
+    let timestamp = chrono::Local::now().format("%Y%m%d_%H%M%S");
+    let log_file = log_dir.join(format!("gittype_{}.log", timestamp));
+
+    let file_appender = FileAppender::builder()
+        .encoder(Box::new(PatternEncoder::new(
+            "{d(%Y-%m-%d %H:%M:%S)} [{l}] {t} - {m}\n",
+        )))
+        .build(log_file)
+        .map_err(|e| {
+            GitTypeError::database_error(format!("Failed to create file appender: {}", e))
+        })?;
+
+    // Console appender for development/debugging (only shows warnings and errors by default)
+    let console_appender = ConsoleAppender::builder()
+        .encoder(Box::new(PatternEncoder::new("[{l}] {m}\n")))
+        .build();
+
+    let config = Config::builder()
+        .appender(Appender::builder().build("file", Box::new(file_appender)))
+        .appender(Appender::builder().build("console", Box::new(console_appender)))
+        .build(Root::builder().appender("file").build(get_log_level()))
+        .map_err(|e| GitTypeError::database_error(format!("Failed to build log config: {}", e)))?;
+
+    log4rs::init_config(config).map_err(|e| {
+        GitTypeError::database_error(format!("Failed to initialize logging: {}", e))
+    })?;
+
+    log::info!(
+        "GitType logging initialized, logs saved to: {}",
+        log_dir.display()
+    );
+    Ok(())
+}
+
+/// Get the log directory path (project/logs/ in dev, ~/.gittype/logs/ in release)
+fn get_log_directory() -> Result<PathBuf> {
+    if cfg!(debug_assertions) {
+        // Development: use project directory
+        let current_dir = std::env::current_dir().map_err(|e| {
+            GitTypeError::ExtractionFailed(format!("Could not get current directory: {}", e))
+        })?;
+        Ok(current_dir.join("logs"))
+    } else {
+        // Release: use home directory
+        let home_dir = dirs::home_dir().ok_or_else(|| {
+            GitTypeError::ExtractionFailed("Could not determine home directory".to_string())
+        })?;
+        Ok(home_dir.join(".gittype").join("logs"))
+    }
+}
+
+/// Get appropriate log level based on build configuration
+fn get_log_level() -> log::LevelFilter {
+    if cfg!(debug_assertions) {
+        // Development builds: show all logs including debug
+        log::LevelFilter::Debug
+    } else {
+        // Release builds: only show info and above
+        log::LevelFilter::Info
+    }
+}
+
+/// Setup minimal console-only logging (fallback if file logging fails)
+pub fn setup_console_logging() {
+    let console_appender = ConsoleAppender::builder()
+        .encoder(Box::new(PatternEncoder::new("[{l}] {m}\n")))
+        .build();
+
+    if let Ok(config) = Config::builder()
+        .appender(Appender::builder().build("console", Box::new(console_appender)))
+        .build(
+            Root::builder()
+                .appender("console")
+                .build(log::LevelFilter::Warn), // Only warnings and errors
+        )
+    {
+        let _ = log4rs::init_config(config);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_get_log_directory() {
+        let log_dir = get_log_directory().unwrap();
+        
+        if cfg!(debug_assertions) {
+            // In debug mode, should be project directory
+            assert!(log_dir.ends_with("logs"));
+        } else {
+            // In release mode, should be ~/.gittype/logs
+            assert!(log_dir.to_string_lossy().contains(".gittype"));
+        }
+    }
+
+    #[test]
+    fn test_setup_console_logging() {
+        // This should not panic
+        setup_console_logging();
+    }
+}

src/storage/database.rs

@@ -2,6 +2,7 @@ use super::migrations::{get_all_migrations, get_latest_version};
 use crate::{error::GitTypeError, Result};
 use rusqlite::Connection;
 use std::path::PathBuf;
+use std::sync::{Arc, Mutex, MutexGuard};
 
 pub struct Database {
     connection: Connection,
@@ -19,15 +20,27 @@ impl Database {
         // Enable foreign key constraints
         connection.execute("PRAGMA foreign_keys = ON", [])?;
         let db = Self { connection };
-        db.init_tables()?;
         Ok(db)
     }
 
+    pub fn init(&self) -> Result<()> {
+        self.init_tables()
+    }
+
     fn get_database_path() -> Result<PathBuf> {
-        let home_dir = dirs::home_dir().ok_or_else(|| {
-            GitTypeError::ExtractionFailed("Could not determine home directory".to_string())
-        })?;
-        Ok(home_dir.join(".gittype").join("gittype.db"))
+        if cfg!(debug_assertions) {
+            // Development: use project directory
+            let current_dir = std::env::current_dir().map_err(|e| {
+                GitTypeError::ExtractionFailed(format!("Could not get current directory: {}", e))
+            })?;
+            Ok(current_dir.join("gittype-dev.db"))
+        } else {
+            // Release: use home directory
+            let home_dir = dirs::home_dir().ok_or_else(|| {
+                GitTypeError::ExtractionFailed("Could not determine home directory".to_string())
+            })?;
+            Ok(home_dir.join(".gittype").join("gittype.db"))
+        }
     }
 
     pub fn init_tables(&self) -> Result<()> {
@@ -88,6 +101,16 @@ impl Database {
     }
 }
 
+pub trait HasDatabase {
+    fn database(&self) -> &Arc<Mutex<Database>>;
+
+    fn db_with_lock(&self) -> Result<MutexGuard<'_, Database>> {
+        self.database()
+            .lock()
+            .map_err(|e| GitTypeError::database_error(format!("Failed to acquire lock: {}", e)))
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -96,22 +119,18 @@ mod tests {
 
     #[test]
     fn test_database_creation() {
-        let temp_dir = TempDir::new().unwrap();
-        let old_home = env::var("HOME").ok();
-        env::set_var("HOME", temp_dir.path());
-
         let result = Database::new();
-
-        // Restore original HOME
-        match old_home {
-            Some(home) => env::set_var("HOME", home),
-            None => env::remove_var("HOME"),
-        }
-
         assert!(result.is_ok());
 
-        let db_path = temp_dir.path().join(".gittype").join("gittype.db");
-        assert!(db_path.exists());
+        // Check that the database file is created in the expected location
+        if cfg!(debug_assertions) {
+            // In debug mode, database should be in project directory
+            assert!(std::path::Path::new("gittype-dev.db").exists());
+        } else {
+            // In release mode, check that the result is ok (file may be in home directory)
+            let db = result.unwrap();
+            assert!(db.get_connection().prepare("SELECT 1").is_ok());
+        }
     }
 
     #[test]

src/storage/mod.rs

@@ -1,6 +1,13 @@
+pub mod daos;
 pub mod database;
 pub mod history;
 pub mod migrations;
+pub mod repositories;
 
-pub use database::Database;
+#[cfg(test)]
+pub mod integration_test;
+
+pub use daos::*;
+pub use database::{Database, HasDatabase};
 pub use history::SessionHistory;
+pub use repositories::*;