feat(main): implement main process with global config, error handling, and report generation

- Initialize global configuration and make it accessible via OnceLock singleton
- Add current working directory output for debugging
- Implement main analysis loop: repo name resolution, git log retrieval, log filtering, formatting, and aggregation
- Generate Markdown report and support graceful error handling
- Use Result and ? operator for clean error propagation
- Add user-friendly error messages for missing or invalid config

Author: chengpeiquan

src/config/error.rs

@@ -1,9 +1,7 @@
-use crate::i18n::t;
-
 #[derive(Debug)]
 pub enum ConfigError {
-    FileNotFound(String),
-    ParseError(String),
+    FileNotFound,
+    ParseError,
     InvalidConfig(String),
 }
 
@@ -12,14 +10,20 @@ impl std::error::Error for ConfigError {}
 impl std::fmt::Display for ConfigError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            ConfigError::FileNotFound(msg) => {
-                write!(f, "{}", t("config_file_not_found").replace("{}", msg))
+            ConfigError::FileNotFound => {
+                write!(
+                    f,
+                    "\nPlease make sure there is a config.json file in the program directory."
+                )
             }
-            ConfigError::ParseError(msg) => {
-                write!(f, "{}", t("failed_parse_config").replace("{}", msg))
+            ConfigError::ParseError => {
+                write!(
+                    f,
+                    "\nFailed to parse config.json, please check the file format."
+                )
             }
             ConfigError::InvalidConfig(msg) => {
-                write!(f, "{}", t("config_invalid").replace("{}", msg))
+                write!(f, "{}", msg)
             }
         }
     }

src/config/mod.rs

@@ -7,20 +7,18 @@ use error::ConfigError;
 use schema::ConfigFile;
 use std::path::Path;
 pub use store::{init, is_chinese, print_config};
-pub use types::{Config, Language};
+pub use types::Config;
 
 const CONFIG_FILE_PATH: &str = "config.json";
 
 /// Initialize configuration from file or use default settings
 pub fn init_config() -> Result<Config, ConfigError> {
     if !Path::new(CONFIG_FILE_PATH).exists() {
-        return Err(ConfigError::FileNotFound(
-            "config.json not found".to_string(),
-        ));
+        return Err(ConfigError::FileNotFound);
     }
 
     ConfigFile::from_file(CONFIG_FILE_PATH)
-        .map_err(|e| ConfigError::ParseError(e.to_string()))
+        .map_err(|_e| ConfigError::ParseError)
         .and_then(|file_config| {
             let config = Config::new_from_file(&file_config)?;
             init(config.clone());

src/i18n/messages/en.rs

@@ -3,10 +3,7 @@ use phf::phf_map;
 pub static MESSAGES: phf::Map<&'static str, &'static str> = phf_map! {
     // Configuration file I/O
     "config_loaded" => "Configuration loaded successfully",
-    "config_not_found" => "Configuration file not found",
-    "failed_init_config" => "Failed to initialize configuration: {}",
     "failed_print_config" => "Failed to print configuration: {}",
-    "config_file_not_found" => "Config file not found: {}",
     "failed_parse_config" => "Failed to parse config: {}",
     "global_config_not_initialized" => "Global configuration not initialized",
 

src/i18n/messages/zh.rs

@@ -3,10 +3,7 @@ use phf::phf_map;
 pub static MESSAGES: phf::Map<&'static str, &'static str> = phf_map! {
     // Configuration file I/O
     "config_loaded" => "配置加载成功",
-    "config_not_found" => "未找到配置文件",
-    "failed_init_config" => "配置初始化失败：{}",
     "failed_print_config" => "打印配置失败：{}",
-    "config_file_not_found" => "配置文件不存在：{}",
     "failed_parse_config" => "解析配置失败：{}",
     "global_config_not_initialized" => "全局配置未初始化",
 

src/main.rs

@@ -0,0 +1,100 @@
+mod config;
+mod i18n;
+mod utils;
+
+use std::collections::HashMap;
+
+use config::{init_config, print_config};
+use i18n::t;
+use utils::{
+    filter_logs::filter_logs,
+    format_log::{format_log, LogInfo},
+    get_repo_logs::get_repo_logs,
+    get_repo_name::get_repo_name,
+    keypress::exit_on_keypress,
+    save_report::save_report_markdown,
+};
+
+fn run() -> Result<(), Box<dyn std::error::Error>> {
+    // Initialize global configuration.
+    // After initialization, the config is stored in a global OnceLock singleton,
+    // and can be accessed from other modules via `config::store::global()`,
+    // such as in the i18n module.
+    let config = init_config()?;
+
+    print_config();
+
+    let mut result: HashMap<String, HashMap<String, Vec<LogInfo>>> = HashMap::new();
+
+    for repo_dir in &config.repos {
+        // Get repo name
+        let repo_name =
+            get_repo_name(repo_dir, &config.format).unwrap_or_else(|| "undefined".to_string());
+
+        let logs = get_repo_logs(repo_dir)?;
+
+        // Append repoName to the beginning of each log line
+        let logs_with_repo: Vec<String> = logs
+            .into_iter()
+            .map(|log| format!("{}|||{}", repo_name, log))
+            .collect();
+
+        // Filter logs according to the rules in the configuration file
+        let filtered_logs = match filter_logs(
+            &logs_with_repo,
+            &config.authors,
+            &config.includes,
+            &config.excludes,
+        ) {
+            Ok(l) => l,
+            Err(e) => {
+                eprintln!(
+                    "{}",
+                    t("err_filter_logs_failed").replace("{}", &e.to_string())
+                );
+                continue;
+            }
+        };
+
+        // Formatting and aggregating logs
+        for log in filtered_logs {
+            let log_info = format_log(&log);
+            let type_name = log_info.type_name.clone();
+            result
+                .entry(repo_name.clone())
+                .or_default()
+                .entry(type_name)
+                .or_default()
+                .push(log_info);
+        }
+
+        // save_report_markdown(&result, "report.txt").expect(t("report_gen_error"));
+        save_report_markdown(&result, "report.txt")?;
+
+        exit_on_keypress(Some(t("press_to_exit")));
+    }
+
+    Ok(())
+}
+
+fn main() {
+    // Print the current working directory
+    // When the program crashes, it can help locate the cause
+    println!("");
+    println!(
+        "Current working directory: \n{}",
+        &std::env::current_dir().unwrap().display()
+    );
+
+    // Using `?` to propagate errors to `main` causes Rust's default error output
+    // (via the `std::process::Termination` trait) to use the Debug format (`{:?}`)
+    // for printing error types. As a result, only the enum variant name is shown
+    // (e.g., `FileNotFound`), not the user-friendly message from the Display trait.
+    //
+    // Wrapping the main logic in a separate `run` function and handling errors
+    // explicitly with `eprintln!` ensures that the Display output is used.
+    if let Err(e) = run() {
+        eprintln!("{}", e); // Use Display format to output the error
+        std::process::exit(1);
+    }
+}

src/utils/format_commit.rs

@@ -1,3 +1,4 @@
+#[cfg(not(test))]
 use crate::i18n::t;
 
 /// Commit type and its category

src/utils/format_log.rs

@@ -1,6 +1,8 @@
 use crate::utils::format_commit::{format_commit, CommitInfo};
 use chrono::{DateTime, Local, NaiveDateTime, TimeZone};
 
+#[allow(dead_code)]
+#[derive(Debug)]
 pub struct LogInfo {
     pub repo: String,
     pub author: String,
@@ -49,21 +51,7 @@ pub fn format_log(log: &str) -> LogInfo {
     let hash = arr.get(4).unwrap_or(&"").replace("'", "#");
     let time_str = arr.get(5).unwrap_or(&"").to_string();
 
-    let (time, unix) = if let Ok(dt) = DateTime::parse_from_rfc2822(&time_str) {
-        let local_dt: DateTime<Local> = dt.with_timezone(&Local);
-        (
-            local_dt.format("%Y-%m-%d %H:%M:%S").to_string(),
-            local_dt.timestamp_millis(),
-        )
-    } else if let Ok(naive_dt) = NaiveDateTime::parse_from_str(&time_str, "%Y-%m-%d %H:%M:%S") {
-        let local_dt = Local.from_local_datetime(&naive_dt).unwrap();
-        (
-            local_dt.format("%Y-%m-%d %H:%M:%S").to_string(),
-            local_dt.timestamp_millis(),
-        )
-    } else {
-        (time_str.clone(), 0)
-    };
+    let (time, unix) = parse_time(&time_str);
 
     let CommitInfo {
         type_name,