use std::sync::atomic::{AtomicBool, Ordering};
use colored::Colorize;
use codewhale_palette as palette;
static VERBOSE: AtomicBool = AtomicBool::new(false);
#[cfg(windows)]
static VERBOSE_SNAPSHOT: AtomicBool = AtomicBool::new(false);
pub struct PhaseTimer {
phase: &'static str,
started: std::time::Instant,
}
impl PhaseTimer {
pub fn start(phase: &'static str) -> Option<Self> {
static ENABLED: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
ENABLED
.get_or_init(|| std::env::var("CODEWHALE_TIMING").is_ok_and(|value| value == "1"))
.then(|| Self {
phase,
started: std::time::Instant::now(),
})
}
}
impl Drop for PhaseTimer {
fn drop(&mut self) {
use std::io::Write;
let receipt = serde_json::json!({
"type": "execution_timing",
"phase": self.phase,
"pid": std::process::id(),
"elapsed_us": self.started.elapsed().as_micros(),
"ended_unix_us": std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.ok()
.map(|elapsed| elapsed.as_micros()),
});
let _ = writeln!(std::io::stderr().lock(), "{receipt}");
}
}
pub fn set_verbose(enabled: bool) {
VERBOSE.store(enabled, Ordering::SeqCst);
}
#[cfg(windows)]
pub fn snapshot_verbose_state() {
VERBOSE_SNAPSHOT.store(is_verbose(), Ordering::SeqCst);
}
#[cfg(windows)]
pub fn restore_verbose_state() {
set_verbose(VERBOSE_SNAPSHOT.load(Ordering::SeqCst));
}
#[must_use]
pub fn env_requests_verbose_logging() -> bool {
std::env::var("CODEWHALE_LOG_LEVEL")
.or_else(|_| std::env::var("DEEPSEEK_LOG_LEVEL"))
.ok()
.is_some_and(|value| log_value_enables_verbose(&value))
}
fn log_value_enables_verbose(value: &str) -> bool {
value.split(',').any(|directive| {
let level = directive
.rsplit('=')
.next()
.unwrap_or(directive)
.trim()
.to_ascii_lowercase();
matches!(level.as_str(), "trace" | "debug" | "info")
})
}
#[must_use]
pub fn is_verbose() -> bool {
VERBOSE.load(Ordering::SeqCst)
}
pub fn info(message: impl AsRef<str>) {
if is_verbose() {
let (r, g, b) = palette::WHALE_ACTION_RGB;
eprintln!("{} {}", "info".truecolor(r, g, b).bold(), message.as_ref());
}
}
pub fn warn(message: impl AsRef<str>) {
if is_verbose() {
let (r, g, b) = palette::WHALE_ACTION_RGB;
eprintln!("{} {}", "warn".truecolor(r, g, b).bold(), message.as_ref());
}
}
#[cfg(test)]
#[cfg(windows)]
mod tests {
use super::*;
use std::sync::Mutex;
static TEST_GUARD: Mutex<()> = Mutex::new(());
#[test]
fn log_value_parser_accepts_common_rust_log_directives() {
assert!(log_value_enables_verbose("debug"));
assert!(log_value_enables_verbose("codewhale_cli=debug"));
assert!(log_value_enables_verbose(
"warn,codewhale_runtime::client=trace"
));
assert!(!log_value_enables_verbose("warn"));
assert!(!log_value_enables_verbose("codewhale_runtime=off"));
}
#[test]
fn snapshot_and_restore_verbose_state_round_trip() {
let _guard = TEST_GUARD.lock().unwrap_or_else(|err| err.into_inner());
set_verbose(false);
snapshot_verbose_state();
set_verbose(true);
restore_verbose_state();
assert!(!is_verbose());
set_verbose(true);
snapshot_verbose_state();
set_verbose(false);
restore_verbose_state();
assert!(is_verbose());
set_verbose(false);
}
#[test]
fn restore_keeps_cli_verbose_state_even_when_env_is_not_verbose() {
let _guard = TEST_GUARD.lock().unwrap_or_else(|err| err.into_inner());
set_verbose(true);
snapshot_verbose_state();
set_verbose(false);
restore_verbose_state();
assert!(is_verbose());
set_verbose(false);
}
}