feat(bucket): implement bucket initialization and logging infrastructure

Add bucket init logic with directory structure creation and log macros
for tracing

9 files changed, 751 insertions, 8 deletions

diff --git a/rola-cli/src/bin/rola.rs b/rola-cli/src/bin/rola.rs
index 0cfe675..a201953 100644
--- a/rola-cli/src/bin/rola.rs
+++ b/rola-cli/src/bin/rola.rs
@@ -5,7 +5,10 @@ use mingling::{
     macros::program_setup,
     setup::{ExitCodeSetup, HelpFlagSetup, QuietFlagSetup},
 };
-use rola_cli::{ThisProgram, locale, res::current_dir::ResCurrentDir};
+use rola_cli::{
+    ThisProgram, locale, output::ColorOutputSetup, output::EnvLoggerSetup,
+    res::current_dir::ResCurrentDir,
+};
 
 fn main() {
     let mut program = ThisProgram::new();
@@ -32,11 +35,18 @@ fn main() {
     program.with_setup(HelpFlagSetup::new(["-h", "--help"]));
     program.with_setup(StandardOutputSetup);
     program.with_setup(ExitCodeSetup::default());
+    program.with_setup(ColorOutputSetup);
 
-    // Execute
+    // stdout/stderr control
     let quiet = program.stdout_setting.quiet;
     let error_output = program.stdout_setting.error_output && !quiet;
     let render_output = program.stdout_setting.render_output && !quiet;
+
+    if error_output {
+        program.with_setup(EnvLoggerSetup);
+    }
+
+    // Execute
     let result = program.exec_without_render().unwrap();
     if !result.is_empty() {
         if result.exit_code == 0 && render_output {
diff --git a/rola-cli/src/error/io.rs b/rola-cli/src/error/io.rs
index 7e4de56..d65b765 100644
--- a/rola-cli/src/error/io.rs
+++ b/rola-cli/src/error/io.rs
@@ -61,7 +61,14 @@ pub enum ErrorIo {
 pub fn render_error_io(err: ErrorIo, ec: &mut ResExitCode) {
     let err: std::io::Error = err.into();
     let content = format!("{:?}", err);
-    let (error_info, exit_code) = match err.kind() {
+    let (error_info, exit_code) = io_error_info(err, content);
+
+    r_println!("{}{}", I18nIoError::io_error_name(), error_info);
+    ec.exit_code = exit_code;
+}
+
+fn io_error_info(err: std::io::Error, content: String) -> (String, i32) {
+    match err.kind() {
         std::io::ErrorKind::NotFound => (I18nIoError::not_found(content), EC_IOERR_NOT_FOUND),
         std::io::ErrorKind::PermissionDenied => (
             I18nIoError::permission_denied(content),
@@ -185,10 +192,7 @@ pub fn render_error_io(err: ErrorIo, ec: &mut ResExitCode) {
         }
         std::io::ErrorKind::Other => (I18nIoError::other(content), EC_IOERR_OTHER),
         _ => (I18nIoError::other(content), EC_IOERR_OTHER),
-    };
-
-    r_println!("{}: {}", I18nIoError::io_error_name(), error_info);
-    ec.exit_code = exit_code;
+    }
 }
 
 impl From<std::io::Error> for ErrorIo {
diff --git a/rola-cli/src/lib.rs b/rola-cli/src/lib.rs
index 54ff09a..b3587e2 100644
--- a/rola-cli/src/lib.rs
+++ b/rola-cli/src/lib.rs
@@ -2,6 +2,7 @@ use std::process::exit;
 
 use mingling::macros::{gen_program, help};
 
+pub mod output;
 pub mod res;
 pub mod tokio_wrapper;
 
@@ -11,12 +12,14 @@ use bucket_mgr::*;
 mod error;
 use error::*;
 
+use crate::output::display::markdown;
+
 #[help]
 fn handle_error_dispatch_not_found(_err: ErrorDispatcherNotFound) {
     let help = locale::helps::Basic::help().trim();
 
     // Print directly to stderr and exit with code 0
-    eprintln!("{}", help);
+    eprintln!("{}", markdown(help));
     exit(0)
 }
 
diff --git a/rola-cli/src/output.rs b/rola-cli/src/output.rs
new file mode 100644
index 0000000..65cafed
--- /dev/null
+++ b/rola-cli/src/output.rs
@@ -0,0 +1,6 @@
+pub mod ansi_control;
+pub mod display;
+pub mod env_logger;
+
+mod setup;
+pub use setup::*;
diff --git a/rola-cli/src/output/ansi_control.rs b/rola-cli/src/output/ansi_control.rs
new file mode 100644
index 0000000..5db8c2a
--- /dev/null
+++ b/rola-cli/src/output/ansi_control.rs
@@ -0,0 +1,32 @@
+use std::sync::atomic::{AtomicBool, Ordering};
+
+mod colorize_wrapper;
+pub use colorize_wrapper::*;
+
+/// Global flag controlling whether ANSI color output is enabled.
+static ANSI_ENABLED: AtomicBool = AtomicBool::new(true);
+
+/// Enable ANSI color codes in output.
+pub fn enable_ansi() {
+    ANSI_ENABLED.store(true, Ordering::Relaxed);
+}
+
+/// Disable ANSI color codes in output.
+pub fn disable_ansi() {
+    ANSI_ENABLED.store(false, Ordering::Relaxed);
+}
+
+/// Set ANSI color output to the specified state (`true` to enable, `false` to disable).
+pub fn set_ansi(enabled: bool) {
+    ANSI_ENABLED.store(enabled, Ordering::Relaxed);
+}
+
+/// Check whether ANSI color output is currently enabled.
+pub fn is_ansi_enabled() -> bool {
+    ANSI_ENABLED.load(Ordering::Relaxed)
+}
+
+/// Returns `true` if ANSI is enabled, `false` otherwise.
+pub fn is_enabled() -> bool {
+    is_ansi_enabled()
+}
diff --git a/rola-cli/src/output/ansi_control/colorize_wrapper.rs b/rola-cli/src/output/ansi_control/colorize_wrapper.rs
new file mode 100644
index 0000000..4c92f66
--- /dev/null
+++ b/rola-cli/src/output/ansi_control/colorize_wrapper.rs
@@ -0,0 +1,209 @@
+use colored::ColoredString;
+use colored::Colorize as _ColoredColorize;
+
+use super::is_ansi_enabled;
+
+macro_rules! if_ansi {
+    ($self:expr, $method:ident $(, $arg:expr)*) => {{
+        if is_ansi_enabled() {
+            _ColoredColorize::$method($self $(, $arg)*)
+        } else {
+            _ColoredColorize::clear($self)
+        }
+    }};
+}
+
+/// A drop-in wrapper for [`colored::Colorize`] that respects the global ANSI
+/// output flag controlled by [`enable_ansi()`](super::enable_ansi) /
+/// [`disable_ansi()`](super::disable_ansi).
+///
+/// When ANSI is **disabled**, all colorization methods return a plain
+/// [`ColoredString`] with no foreground/background color or style —
+/// effectively a no-op.
+///
+/// Import this trait instead of `colored::Colorize` to automatically honour
+/// the `--no-color` / `--quiet` flags set by the CLI.
+///
+/// # Example
+///
+/// ```ignore
+/// use rola_cli::res::ansi_control::Colorize;
+///
+/// println!("{}", "error".red().bold());
+/// //    ^  ANSI on  → red bold text
+/// //    ^  ANSI off → plain "error"
+/// ```
+pub trait Colorize: _ColoredColorize {
+    fn black(self) -> ColoredString {
+        if_ansi!(self, black)
+    }
+    fn red(self) -> ColoredString {
+        if_ansi!(self, red)
+    }
+    fn green(self) -> ColoredString {
+        if_ansi!(self, green)
+    }
+    fn yellow(self) -> ColoredString {
+        if_ansi!(self, yellow)
+    }
+    fn blue(self) -> ColoredString {
+        if_ansi!(self, blue)
+    }
+    fn magenta(self) -> ColoredString {
+        if_ansi!(self, magenta)
+    }
+    fn purple(self) -> ColoredString {
+        if_ansi!(self, purple)
+    }
+    fn cyan(self) -> ColoredString {
+        if_ansi!(self, cyan)
+    }
+    fn white(self) -> ColoredString {
+        if_ansi!(self, white)
+    }
+
+    fn bright_black(self) -> ColoredString {
+        if_ansi!(self, bright_black)
+    }
+    fn bright_red(self) -> ColoredString {
+        if_ansi!(self, bright_red)
+    }
+    fn bright_green(self) -> ColoredString {
+        if_ansi!(self, bright_green)
+    }
+    fn bright_yellow(self) -> ColoredString {
+        if_ansi!(self, bright_yellow)
+    }
+    fn bright_blue(self) -> ColoredString {
+        if_ansi!(self, bright_blue)
+    }
+    fn bright_magenta(self) -> ColoredString {
+        if_ansi!(self, bright_magenta)
+    }
+    fn bright_purple(self) -> ColoredString {
+        if_ansi!(self, bright_purple)
+    }
+    fn bright_cyan(self) -> ColoredString {
+        if_ansi!(self, bright_cyan)
+    }
+    fn bright_white(self) -> ColoredString {
+        if_ansi!(self, bright_white)
+    }
+
+    fn truecolor(self, r: u8, g: u8, b: u8) -> ColoredString {
+        if_ansi!(self, truecolor, r, g, b)
+    }
+
+    fn color<C: Into<colored::Color>>(self, color: C) -> ColoredString {
+        if is_ansi_enabled() {
+            _ColoredColorize::color(self, color)
+        } else {
+            _ColoredColorize::clear(self)
+        }
+    }
+
+    fn on_black(self) -> ColoredString {
+        if_ansi!(self, on_black)
+    }
+    fn on_red(self) -> ColoredString {
+        if_ansi!(self, on_red)
+    }
+    fn on_green(self) -> ColoredString {
+        if_ansi!(self, on_green)
+    }
+    fn on_yellow(self) -> ColoredString {
+        if_ansi!(self, on_yellow)
+    }
+    fn on_blue(self) -> ColoredString {
+        if_ansi!(self, on_blue)
+    }
+    fn on_magenta(self) -> ColoredString {
+        if_ansi!(self, on_magenta)
+    }
+    fn on_purple(self) -> ColoredString {
+        if_ansi!(self, on_purple)
+    }
+    fn on_cyan(self) -> ColoredString {
+        if_ansi!(self, on_cyan)
+    }
+    fn on_white(self) -> ColoredString {
+        if_ansi!(self, on_white)
+    }
+
+    fn on_bright_black(self) -> ColoredString {
+        if_ansi!(self, on_bright_black)
+    }
+    fn on_bright_red(self) -> ColoredString {
+        if_ansi!(self, on_bright_red)
+    }
+    fn on_bright_green(self) -> ColoredString {
+        if_ansi!(self, on_bright_green)
+    }
+    fn on_bright_yellow(self) -> ColoredString {
+        if_ansi!(self, on_bright_yellow)
+    }
+    fn on_bright_blue(self) -> ColoredString {
+        if_ansi!(self, on_bright_blue)
+    }
+    fn on_bright_magenta(self) -> ColoredString {
+        if_ansi!(self, on_bright_magenta)
+    }
+    fn on_bright_purple(self) -> ColoredString {
+        if_ansi!(self, on_bright_purple)
+    }
+    fn on_bright_cyan(self) -> ColoredString {
+        if_ansi!(self, on_bright_cyan)
+    }
+    fn on_bright_white(self) -> ColoredString {
+        if_ansi!(self, on_bright_white)
+    }
+
+    fn on_truecolor(self, r: u8, g: u8, b: u8) -> ColoredString {
+        if_ansi!(self, on_truecolor, r, g, b)
+    }
+
+    fn on_color<C: Into<colored::Color>>(self, color: C) -> ColoredString {
+        if is_ansi_enabled() {
+            _ColoredColorize::on_color(self, color)
+        } else {
+            _ColoredColorize::clear(self)
+        }
+    }
+
+    fn clear(self) -> ColoredString {
+        if_ansi!(self, clear)
+    }
+    fn normal(self) -> ColoredString {
+        if_ansi!(self, normal)
+    }
+    fn bold(self) -> ColoredString {
+        if_ansi!(self, bold)
+    }
+    fn dimmed(self) -> ColoredString {
+        if_ansi!(self, dimmed)
+    }
+    fn italic(self) -> ColoredString {
+        if_ansi!(self, italic)
+    }
+    fn underline(self) -> ColoredString {
+        if_ansi!(self, underline)
+    }
+    fn blink(self) -> ColoredString {
+        if_ansi!(self, blink)
+    }
+    #[allow(deprecated)]
+    fn reverse(self) -> ColoredString {
+        if_ansi!(self, reverse)
+    }
+    fn reversed(self) -> ColoredString {
+        if_ansi!(self, reversed)
+    }
+    fn hidden(self) -> ColoredString {
+        if_ansi!(self, hidden)
+    }
+    fn strikethrough(self) -> ColoredString {
+        if_ansi!(self, strikethrough)
+    }
+}
+
+impl<T: _ColoredColorize> Colorize for T {}
diff --git a/rola-cli/src/output/display.rs b/rola-cli/src/output/display.rs
new file mode 100644
index 0000000..0845456
--- /dev/null
+++ b/rola-cli/src/output/display.rs
@@ -0,0 +1,384 @@
+use crate::output::ansi_control::Colorize;
+use std::collections::VecDeque;
+
+/// Trait for adding markdown formatting to strings
+pub trait Markdown {
+    fn markdown(&self) -> String;
+}
+
+impl Markdown for &str {
+    fn markdown(&self) -> String {
+        markdown(self)
+    }
+}
+
+impl Markdown for String {
+    fn markdown(&self) -> String {
+        markdown(self)
+    }
+}
+
+/// Converts a string to colored/formatted text with ANSI escape codes.
+///
+/// Supported syntax:
+/// - Bold: `**text**`
+/// - Italic: `*text*`
+/// - Underline: `_text_`
+/// - Angle-bracketed content: `<text>` (displayed as cyan)
+/// - Inline code: `` `text` `` (displayed as green)
+/// - Color tags: `[[color_name]]` and `[[/]]` to close color
+/// - Escape characters: `\*`, `\<`, `\>`, `` \` ``, `\_` for literal characters
+/// - Headings: `# Heading 1`, `## Heading 2`, up to `###### Heading 6`
+/// - Blockquote: `> text` (displays a gray background marker at the beginning of the line)
+///
+/// Color tags support the following color names:
+/// Color tags support the following color names:
+///
+/// | Type                    | Color Names                                                                 |
+/// |-------------------------|-----------------------------------------------------------------------------|
+/// | Standard colors         | `black`, `red`, `green`, `yellow`, `blue`, `magenta`, `cyan`, `white`       |
+/// | Bright colors           | `bright_black`                                                              |
+/// |                         | `bright_red`                                                                |
+/// |                         | `bright_green`                                                              |
+/// |                         | `bright_yellow`                                                             |
+/// |                         | `bright_blue`                                                               |
+/// |                         | `bright_magenta`                                                            |
+/// |                         | `bright_cyan`                                                               |
+/// |                         | `bright_white`                                                              |
+/// | Bright color shorthands | `b_black`                                                                   |
+/// |                         | `b_red`                                                                     |
+/// |                         | `b_green`                                                                   |
+/// |                         | `b_yellow`                                                                  |
+/// |                         | `b_blue`                                                                    |
+/// |                         | `b_magenta`                                                                 |
+/// |                         | `b_cyan`                                                                    |
+/// |                         | `b_white`                                                                   |
+/// | Gray colors             | `gray`/`grey`                                                               |
+/// |                         | `bright_gray`/`bright_grey`                                                 |
+/// |                         | `b_gray`/`b_grey`                                                           |
+///
+/// Color tags can be nested, `[[/]]` will close the most recently opened color tag.
+///
+/// # Arguments
+/// * `text` - The text to format, can be any type that implements `AsRef<str>`
+///
+/// # Returns
+/// Returns a `String` containing ANSI escape codes that can display colored/formatted text in ANSI-supported terminals.
+///
+/// # Examples
+/// ```
+/// # use mingling_cli::display::markdown;
+/// let formatted = markdown("Hello **world**!");
+/// println!("{}", formatted);
+///
+/// let colored = markdown("[[red]]Red text[[/]] and normal text");
+/// println!("{}", colored);
+///
+/// let nested = markdown("[[blue]]Blue [[green]]Green[[/]] Blue[[/]] normal");
+/// println!("{}", nested);
+/// ```
+pub fn markdown(text: impl AsRef<str>) -> String {
+    let text = text.as_ref();
+    let lines: Vec<&str> = text.lines().collect();
+    let mut result = String::new();
+    let mut content_indent = 0;
+
+    for line in lines {
+        // Don't trim the line initially, we need to check if it starts with #
+        let trimmed_line = line.trim();
+        let mut line_result = String::new();
+
+        // Check if line starts with # for heading
+        // Check if the original line (not trimmed) starts with #
+        if line.trim_start().starts_with('#') {
+            let chars: Vec<char> = line.trim_start().chars().collect();
+            let mut level = 0;
+
+            // Count # characters at the beginning
+            while level < chars.len() && level < 7 && chars[level] == '#' {
+                level += 1;
+            }
+
+            // Cap level at 6
+            let effective_level = if level > 6 { 6 } else { level };
+
+            // Skip # characters and any whitespace after them
+            let mut content_start = level;
+            while content_start < chars.len() && chars[content_start].is_whitespace() {
+                content_start += 1;
+            }
+
+            // Extract heading content
+            let heading_content: String = if content_start < chars.len() {
+                chars[content_start..].iter().collect()
+            } else {
+                String::new()
+            };
+
+            // Process the heading content with formatting
+            let processed_content = process_line(&heading_content);
+
+            // Format heading as white background, black text, bold
+            // ANSI codes: \x1b[1m for bold, \x1b[47m for white background, \x1b[30m for black text
+            let formatted_heading = format!("\x1b[1m\x1b[47m\x1b[30m {processed_content} \x1b[0m");
+
+            // Add indentation to the heading line itself
+            // Heading indentation = level - 1
+            let heading_indent = if effective_level > 0 {
+                effective_level - 1
+            } else {
+                0
+            };
+            let indent = " ".repeat(heading_indent);
+            line_result.push_str(&indent);
+            line_result.push_str(&formatted_heading);
+
+            // Update content indent level for subsequent content
+            // Content after heading should be indented by effective_level
+            content_indent = effective_level;
+        } else if !trimmed_line.is_empty() {
+            // Process regular line with existing formatting
+            let processed_line = process_line_with_quote(trimmed_line);
+
+            // Add indentation based on content_indent
+            let indent = " ".repeat(content_indent);
+            line_result.push_str(&indent);
+            line_result.push_str(&processed_line);
+        } else {
+            line_result.push(' ');
+        }
+
+        if !line_result.is_empty() {
+            result.push_str(&line_result);
+            result.push('\n');
+        }
+    }
+
+    // Remove trailing newline
+    if result.ends_with('\n') {
+        result.pop();
+    }
+
+    result
+}
+
+// Helper function to process a single line with existing formatting and handle > quotes
+fn process_line_with_quote(line: &str) -> String {
+    let chars: Vec<char> = line.chars().collect();
+
+    // Check if line starts with '>' and not escaped
+    if !chars.is_empty() && chars[0] == '>' {
+        // Check if it's escaped
+        if chars.len() > 1 && chars[1] == '\\' {
+            // It's \>, so treat as normal text starting from position 0
+            return process_line(line);
+        }
+
+        // It's a regular > at the beginning, replace with gray background gray text space
+        let gray_bg_space = "\x1b[48;5;242m\x1b[38;5;242m \x1b[0m";
+        let rest_of_line = if chars.len() > 1 {
+            chars[1..].iter().collect::<String>()
+        } else {
+            String::new()
+        };
+
+        // Process the rest of the line normally
+        let processed_rest = process_line(&rest_of_line);
+
+        // Combine the gray background space with the processed rest
+        format!("{gray_bg_space}{processed_rest}")
+    } else {
+        // No > at the beginning, process normally
+        process_line(line)
+    }
+}
+
+// Helper function to process a single line with existing formatting
+fn process_line(line: &str) -> String {
+    let mut result = String::new();
+    let mut color_stack: VecDeque<String> = VecDeque::new();
+
+    let chars: Vec<char> = line.chars().collect();
+    let mut i = 0;
+
+    while i < chars.len() {
+        // Check for escape character \
+        if chars[i] == '\\' && i + 1 < chars.len() {
+            let escaped_char = chars[i + 1];
+            // Only escape specific characters
+            if matches!(escaped_char, '*' | '<' | '>' | '`' | '_') {
+                let mut escaped_text = escaped_char.to_string();
+                apply_color_stack(&mut escaped_text, &color_stack);
+                result.push_str(&escaped_text);
+                i += 2;
+                continue;
+            }
+        }
+
+        // Check for color tag start [[color]]
+        if i + 1 < chars.len()
+            && chars[i] == '['
+            && chars[i + 1] == '['
+            && let Some(end) = find_tag_end(&chars, i)
+        {
+            let tag_content: String = chars[i + 2..end].iter().collect();
+
+            // Check if it's a closing tag [[/]]
+            if tag_content == "/" {
+                color_stack.pop_back();
+            } else {
+                // It's a color tag
+                color_stack.push_back(tag_content.clone());
+            }
+            i = end + 2;
+            continue;
+        }
+
+        // Check for bold **text**
+        if i + 1 < chars.len()
+            && chars[i] == '*'
+            && chars[i + 1] == '*'
+            && let Some(end) = find_matching(&chars, i + 2, "**")
+        {
+            let bold_text: String = chars[i + 2..end].iter().collect();
+            let mut formatted_text = bold_text.bold().to_string();
+            apply_color_stack(&mut formatted_text, &color_stack);
+            result.push_str(&formatted_text);
+            i = end + 2;
+            continue;
+        }
+
+        // Check for italic *text*
+        if chars[i] == '*'
+            && let Some(end) = find_matching(&chars, i + 1, "*")
+        {
+            let italic_text: String = chars[i + 1..end].iter().collect();
+            let mut formatted_text = italic_text.italic().to_string();
+            apply_color_stack(&mut formatted_text, &color_stack);
+            result.push_str(&formatted_text);
+            i = end + 1;
+            continue;
+        }
+
+        // Check for underline _text_
+        if chars[i] == '_'
+            && let Some(end) = find_matching(&chars, i + 1, "_")
+        {
+            let underline_text: String = chars[i + 1..end].iter().collect();
+            let mut formatted_text = format!("\x1b[4m{underline_text}\x1b[0m");
+            apply_color_stack(&mut formatted_text, &color_stack);
+            result.push_str(&formatted_text);
+            i = end + 1;
+            continue;
+        }
+
+        // Check for angle-bracketed content <text>
+        if chars[i] == '<'
+            && let Some(end) = find_matching(&chars, i + 1, ">")
+        {
+            // Include the angle brackets in the output
+            let angle_text: String = chars[i..=end].iter().collect();
+            let mut formatted_text = angle_text.cyan().to_string();
+            apply_color_stack(&mut formatted_text, &color_stack);
+            result.push_str(&formatted_text);
+            i = end + 1;
+            continue;
+        }
+
+        // Check for inline code `text`
+        if chars[i] == '`'
+            && let Some(end) = find_matching(&chars, i + 1, "`")
+        {
+            // Include the backticks in the output
+            let code_text: String = chars[i..=end].iter().collect();
+            let mut formatted_text = code_text.green().to_string();
+            apply_color_stack(&mut formatted_text, &color_stack);
+            result.push_str(&formatted_text);
+            i = end + 1;
+            continue;
+        }
+
+        // Regular character
+        let mut current_char = chars[i].to_string();
+        apply_color_stack(&mut current_char, &color_stack);
+        result.push_str(&current_char);
+        i += 1;
+    }
+
+    result
+}
+
+// Helper function to find matching delimiter
+fn find_matching(chars: &[char], start: usize, delimiter: &str) -> Option<usize> {
+    let delim_chars: Vec<char> = delimiter.chars().collect();
+    let delim_len = delim_chars.len();
+
+    let mut j = start;
+    while j < chars.len() {
+        if delim_len == 1 {
+            if chars[j] == delim_chars[0] {
+                return Some(j);
+            }
+        } else if j + 1 < chars.len()
+            && chars[j] == delim_chars[0]
+            && chars[j + 1] == delim_chars[1]
+        {
+            return Some(j);
+        }
+        j += 1;
+    }
+    None
+}
+
+// Helper function to find color tag end
+fn find_tag_end(chars: &[char], start: usize) -> Option<usize> {
+    let mut j = start + 2;
+    while j + 1 < chars.len() {
+        if chars[j] == ']' && chars[j + 1] == ']' {
+            return Some(j);
+        }
+        j += 1;
+    }
+    None
+}
+
+// Helper function to apply color stack to text
+fn apply_color_stack(text: &mut String, color_stack: &VecDeque<String>) {
+    let mut result = text.clone();
+    for color in color_stack.iter().rev() {
+        result = apply_color(&result, color);
+    }
+    *text = result;
+}
+
+// Helper function to apply color to text
+fn apply_color(text: impl AsRef<str>, color_name: impl AsRef<str>) -> String {
+    let text = text.as_ref();
+    let color_name = color_name.as_ref();
+    match color_name {
+        // Normal colors
+        "black" => text.black().to_string(),
+        "red" => text.red().to_string(),
+        "green" => text.green().to_string(),
+        "yellow" => text.yellow().to_string(),
+        "blue" => text.blue().to_string(),
+        "magenta" => text.magenta().to_string(),
+        "cyan" => text.cyan().to_string(),
+        "white" | "b_white" | "bright_gray" | "bright_grey" | "b_gray" | "b_grey" => {
+            text.white().to_string()
+        }
+
+        // Bright colors and their b_ short aliases
+        "bright_black" | "b_black" | "gray" | "grey" => text.bright_black().to_string(),
+        "bright_red" | "b_red" => text.bright_red().to_string(),
+        "bright_green" | "b_green" => text.bright_green().to_string(),
+        "bright_yellow" | "b_yellow" => text.bright_yellow().to_string(),
+        "bright_blue" | "b_blue" => text.bright_blue().to_string(),
+        "bright_magenta" | "b_magenta" => text.bright_magenta().to_string(),
+        "bright_cyan" | "b_cyan" => text.bright_cyan().to_string(),
+        "bright_white" => text.bright_white().to_string(),
+
+        // Default to white if color not recognized
+        _ => text.to_string(),
+    }
+}
diff --git a/rola-cli/src/output/env_logger.rs b/rola-cli/src/output/env_logger.rs
new file mode 100644
index 0000000..289de77
--- /dev/null
+++ b/rola-cli/src/output/env_logger.rs
@@ -0,0 +1,54 @@
+use chrono::Local;
+use std::io::Write;
+
+use crate::output::ansi_control::Colorize;
+
+/// Simple env logger that prints formatted messages.
+/// Usage: `env_logger::init_with(EnvLogger { show_time: true, show_level: true });`
+pub struct EnvLogger {
+    pub show_time: bool,
+    pub show_level: bool,
+    pub level: log::Level,
+}
+
+impl log::Log for EnvLogger {
+    fn enabled(&self, metadata: &log::Metadata) -> bool {
+        metadata.level() <= log::Level::Info
+    }
+
+    fn log(&self, record: &log::Record) {
+        if !self.enabled(record.metadata()) {
+            return;
+        }
+
+        let mut buf = Vec::new();
+
+        if self.show_time {
+            let now = Local::now().format("%Y-%m-%d %H:%M:%S%.3f");
+            write!(buf, "[{}] ", now).ok();
+        }
+
+        if self.show_level {
+            let level_str = match record.level() {
+                log::Level::Trace => "TRACE".bright_black(),
+                log::Level::Debug => "DEBUG".cyan(),
+                log::Level::Info => "INFO".green(),
+                log::Level::Warn => "WARN".yellow(),
+                log::Level::Error => "ERROR".red(),
+            };
+            write!(buf, "{}: ", level_str.bold()).ok();
+        }
+
+        write!(buf, "{}", record.args()).ok();
+        eprintln!("{}", String::from_utf8_lossy(&buf));
+    }
+
+    fn flush(&self) {}
+}
+
+/// Initialize the env logger with the given configuration.
+pub fn init_envlogger(config: EnvLogger) {
+    log::set_boxed_logger(Box::new(config))
+        .map(|()| log::set_max_level(log::LevelFilter::Info))
+        .ok();
+}
diff --git a/rola-cli/src/output/setup.rs b/rola-cli/src/output/setup.rs
new file mode 100644
index 0000000..824348b
--- /dev/null
+++ b/rola-cli/src/output/setup.rs
@@ -0,0 +1,41 @@
+use mingling::{Program, macros::program_setup};
+use shared_functions::info;
+
+use crate::{
+    ThisProgram,
+    output::{
+        ansi_control::disable_ansi,
+        env_logger::{EnvLogger, init_envlogger},
+    },
+};
+
+#[program_setup]
+pub fn color_output_setup(program: &mut Program<ThisProgram>) {
+    program.global_flag("--no-color", |_| {
+        disable_ansi();
+    });
+}
+
+#[program_setup]
+pub fn env_logger_setup(program: &mut Program<ThisProgram>) {
+    program.stdout_setting.verbose = program.pick_global_flag(["-V", "--verbose"]);
+    let log_show_time = program.pick_global_flag("--log-time");
+    let log_level = program
+        .pick_global_argument("--log-level")
+        .unwrap_or("info".to_string());
+    if program.stdout_setting.verbose {
+        init_envlogger(EnvLogger {
+            show_time: log_show_time,
+            show_level: log_level.as_str() != "disable",
+            level: match log_level.as_str() {
+                "trace" => log::Level::Trace,
+                "debug" => log::Level::Debug,
+                "warn" => log::Level::Warn,
+                "error" => log::Level::Error,
+                _ => log::Level::Info,
+            },
+        });
+    }
+
+    info!("Verbose mode enabled!");
+}