refactor: extract utilities and streamline code organization

- add new utils module with shared functions for env handling, output formatting, and error processing
- refactor main module to eliminate duplicate imports and leverage utils for cleaner logic

Signed-off-by: mingcheng <mingcheng@apache.org>

Author: mingcheng

src/cli.rs

@@ -13,9 +13,7 @@
  */
 
 use clap::Parser;
-mod built_info {
-    include!(concat!(env!("OUT_DIR"), "/built.rs"));
-}
+use crate::built_info;
 
 #[derive(Debug, Parser)]
 #[command(name = built_info::PKG_NAME, about = built_info::PKG_DESCRIPTION, version = built_info::PKG_VERSION, author = built_info::PKG_AUTHORS)]

src/lib.rs

@@ -12,6 +12,11 @@
  * Last Modified: 2025-03-03 19:36:07
  */
 
+pub mod built_info {
+    include!(concat!(env!("OUT_DIR"), "/built.rs"));
+}
+
 pub mod cli;
 pub mod git;
 pub mod openai;
+pub mod utils;

src/main.rs

@@ -12,48 +12,25 @@
  * Last Modified: 2025-09-26 15:45:37
  */
 
+use aigitcommit::built_info::{PKG_NAME, PKG_VERSION};
 use aigitcommit::cli::Cli;
 use aigitcommit::git::message::GitMessage;
 use aigitcommit::git::repository::Repository;
 use aigitcommit::openai;
 use aigitcommit::openai::OpenAI;
 use arboard::Clipboard;
-use async_openai::error::OpenAIError;
 use async_openai::types::{
     ChatCompletionRequestSystemMessageArgs, ChatCompletionRequestUserMessageArgs,
 };
 use clap::Parser;
 use std::error::Error;
-use std::fs::File;
+use std::fs;
 use std::io::Write;
-use std::{env, fs};
 use tracing::{Level, debug, trace};
 
-use crate::built_info::{PKG_NAME, PKG_VERSION};
-use crate::utils::print_table;
-mod built_info {
-    include!(concat!(env!("OUT_DIR"), "/built.rs"));
-}
-mod utils;
-
-/// The output format for the commit message
-#[derive(Debug)]
-enum OutPutFormat {
-    Stdout,
-    Table,
-    Json,
-}
-
-/// Detect the output format based on the command line arguments
-fn detect_output_format(cli: &Cli) -> OutPutFormat {
-    if cli.json {
-        return OutPutFormat::Json;
-    } else if cli.no_table {
-        return OutPutFormat::Stdout;
-    }
-
-    OutPutFormat::Table
-}
+use aigitcommit::utils::{
+    OutputFormat, check_env_variables, format_openai_error, get_env, save_to_file, should_signoff,
+};
 
 #[tokio::main]
 async fn main() -> std::result::Result<(), Box<dyn Error>> {
@@ -73,56 +50,31 @@ async fn main() -> std::result::Result<(), Box<dyn Error>> {
         );
     }
 
-    // Get the specified model name from environment variable, default to "gpt-4"
-    let model_name = env::var("OPENAI_MODEL_NAME").unwrap_or_else(|_| String::from("gpt-5"));
+    // Get the specified model name from environment variable, default to "gpt-5"
+    let model_name = get_env("OPENAI_MODEL_NAME", "gpt-5");
 
     // Instantiate OpenAI client, ready to send requests to the OpenAI API
     let client = openai::OpenAI::new();
 
     // Check if the environment variables are set and print the configured values
     if cli.check_env {
-        fn check_and_print_env(var_name: &str) {
-            match env::var(var_name) {
-                Ok(value) => {
-                    debug!("{} is set to {}", var_name, value);
-                    // Print the value of the environment variable
-                    println!("{:20}\t{}", var_name, value);
-                }
-                Err(_) => {
-                    debug!("{} is not set", var_name);
-                }
-            }
-        }
-
-        trace!("check env option is enabled, will check the OpenAI API key and model name");
-        debug!("the model name is `{}`", &model_name);
-
-        [
-            "OPENAI_API_BASE",
-            "OPENAI_API_TOKEN",
-            "OPENAI_MODEL_NAME",
-            "OPENAI_API_PROXY",
-            "OPENAI_API_TIMEOUT",
-            "OPENAI_API_MAX_TOKENS",
-            "GIT_AUTO_SIGNOFF",
-        ]
-        .iter()
-        .for_each(|v| check_and_print_env(v));
+        trace!("check env option is enabled");
+        debug!("model name: `{}`", &model_name);
 
+        check_env_variables();
         return Ok(());
     }
 
     // Check if the model name is valid
     if cli.check_model {
-        trace!("check option is enabled, will check the OpenAI API key and model name");
-        debug!("the model name is `{}`", &model_name);
+        trace!("check model option is enabled");
+        debug!("model name: `{}`", &model_name);
 
         match client.check_model(&model_name).await {
             Ok(()) => {
                 println!(
                     "the model name `{}` is available, {} is ready for use!",
-                    model_name,
-                    built_info::PKG_NAME
+                    model_name, PKG_NAME
                 );
             }
             Err(e) => {
@@ -133,16 +85,13 @@ async fn main() -> std::result::Result<(), Box<dyn Error>> {
         return Ok(());
     }
 
-    // Check if the specified path is a valid directory
+    // Initialize repository
     let repo_dir = fs::canonicalize(&cli.repo_path)?;
-
-    // Check if the directory is empty
     if !repo_dir.is_dir() {
         return Err("the specified path is not a directory".into());
     }
 
     trace!("specified repository directory: {:?}", repo_dir);
-    // Check if the directory is a valid git repository
     let repository = Repository::new(repo_dir.to_str().unwrap_or("."))?;
 
     // Get the diff and logs from the repository
@@ -181,59 +130,31 @@ async fn main() -> std::result::Result<(), Box<dyn Error>> {
     ];
 
     // Send the request to OpenAI API and get the response
-    let result = match client.chat(&model_name.to_string(), messages).await {
+    let result = match client.chat(&model_name, messages).await {
         Ok(s) => s,
         Err(e) => {
-            let message = match e {
-                OpenAIError::Reqwest(_) | OpenAIError::StreamError(_) => {
-                    "network request error".to_string()
-                }
-                OpenAIError::JSONDeserialize(_error, message) => {
-                    format!("json deserialization error: {message}").to_string()
-                }
-                OpenAIError::InvalidArgument(_) => "invalid argument".to_string(),
-                OpenAIError::FileSaveError(_) | OpenAIError::FileReadError(_) => {
-                    "io error".to_string()
-                }
-                OpenAIError::ApiError(e) => format!("api error {e:?}"),
-            };
-
+            let message = format_openai_error(e);
             return Err(message.into());
         }
     };
 
-    let (title, content) = result.split_once("\n\n").unwrap();
+    let (title, content) = result
+        .split_once("\n\n")
+        .ok_or("Invalid response format: expected title and content separated by double newline")?;
 
-    // Detect auto signoff from environment variable
-    let need_signoff = cli.signoff
-        || env::var("GIT_AUTO_SIGNOFF")
-            .map(|v| v == "1" || v.eq_ignore_ascii_case("true"))
-            .unwrap_or(false);
+    // Detect auto signoff from environment variable or CLI flag
+    let need_signoff = should_signoff(cli.signoff);
 
     let message: GitMessage = GitMessage::new(&repository, title, content, need_signoff)?;
 
     // Decide the output format based on the command line arguments
-    match detect_output_format(&cli) {
-        OutPutFormat::Stdout => {
-            // Write the commit message to stdout
-            trace!("write to stdout, and finish the process");
-            writeln!(std::io::stdout(), "{}", message)?;
-        }
-        OutPutFormat::Json => {
-            // Print the commit message in JSON format
-            let json = serde_json::to_string_pretty(&message)?;
-            writeln!(std::io::stdout(), "{}", json)?;
-        }
-        OutPutFormat::Table => {
-            // Default print message in table
-            print_table(&message.title, &message.content);
-        }
-    };
+    let output_format = OutputFormat::detect(cli.json, cli.no_table);
+    output_format.write(&message)?;
 
     // Copy the commit message to clipboard if the --copy option is enabled
     if cli.copy_to_clipboard {
         let mut clipboard = Clipboard::new()?;
-        clipboard.set_text(format!("{}", &message))?;
+        clipboard.set_text(message.to_string())?;
         writeln!(
             std::io::stdout(),
             "the commit message has been copied to clipboard."
@@ -264,14 +185,10 @@ async fn main() -> std::result::Result<(), Box<dyn Error>> {
     // If the --save option is enabled, save the commit message to a file
     if !cli.save.is_empty() {
         trace!("save option is enabled, will save the commit message to a file");
-        let save_path = &cli.save;
-        debug!("the save file path is {:?}", &save_path);
-
-        let mut file = File::create(save_path)?;
-        file.write_all(result.as_bytes())?;
-        file.flush()?;
+        debug!("the save file path is {:?}", &cli.save);
 
-        writeln!(std::io::stdout(), "commit message saved to {save_path}")?;
+        save_to_file(&cli.save, &result)?;
+        writeln!(std::io::stdout(), "commit message saved to {}", cli.save)?;
     }
 
     Ok(())

src/openai.rs

@@ -12,11 +12,8 @@
  * Last Modified: 2025-09-26 15:51:48
  */
 
-// Include the generated-file as a separate module
-mod built_info {
-    include!(concat!(env!("OUT_DIR"), "/built.rs"));
-}
-
+use crate::built_info;
+use crate::utils::get_env;
 use askama::Template;
 use async_openai::config::OPENAI_API_BASE;
 use async_openai::error::OpenAIError;
@@ -28,7 +25,6 @@ use async_openai::{
 use log::trace;
 use reqwest::header::{HeaderMap, HeaderValue};
 use reqwest::{ClientBuilder, Proxy};
-use std::env;
 use std::error::Error;
 use std::time::Duration;
 use tracing::debug;
@@ -55,10 +51,8 @@ impl OpenAI {
     pub fn new() -> Self {
         // Set up OpenAI client configuration
         let ai_config = OpenAIConfig::new()
-            .with_api_key(env::var("OPENAI_API_TOKEN").unwrap_or_else(|_| String::from("")))
-            .with_api_base(
-                env::var("OPENAI_API_BASE").unwrap_or_else(|_| String::from(OPENAI_API_BASE)),
-            )
+            .with_api_key(get_env("OPENAI_API_TOKEN", ""))
+            .with_api_base(get_env("OPENAI_API_BASE", OPENAI_API_BASE))
             .with_org_id(built_info::PKG_NAME);
 
         // Set up HTTP client builder with default headers
@@ -80,14 +74,14 @@ impl OpenAI {
             });
 
         // Set up proxy if specified
-        let proxy_addr: String = env::var("OPENAI_API_PROXY").unwrap_or_else(|_| String::from(""));
+        let proxy_addr = get_env("OPENAI_API_PROXY", "");
         if !proxy_addr.is_empty() {
             trace!("Using proxy: {proxy_addr}");
             http_client_builder = http_client_builder.proxy(Proxy::all(proxy_addr).unwrap());
         }
 
-        let request_timeout =
-            env::var("OPENAI_REQUEST_TIMEOUT").unwrap_or_else(|_| String::from(""));
+        // Set up request timeout if specified
+        let request_timeout = get_env("OPENAI_REQUEST_TIMEOUT", "");
         if !request_timeout.is_empty()
             && let Ok(timeout) = request_timeout.parse::<u64>()
         {