feat: add ANSI color support for test runner and error messages

- Add colored output for test results (green=passed, red=failed, yellow=ignored)
- Add colored error messages with red error prefix and underlines
- Add automatic TTY detection to disable colors when output is piped
- Add global --no-color flag to disable all colored output
- Add --no-color flag specifically for test command
- Use termcolor crate for cross-platform color support
- Use atty crate for TTY detection
- Fix test script compatibility by ensuring proper output formatting

Colors are automatically disabled when:
- Output is piped or redirected to a file
- The --no-color flag is used
- Not running in a TTY environment

This makes error messages and test results much easier to read while
maintaining compatibility with scripts and CI environments.

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

Co-Authored-By: Claude <[email protected]>

Author: fcoury

Cargo.lock

@@ -5,12 +5,14 @@ edition = "2021"
 
 [dependencies]
 anyhow = "1.0.86"
+atty = "0.2"
 clap = { version = "4.5.8", features = ["derive"] }
 indexmap = "2.2.6"
 rustyline = "14.0.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 simple-home-dir = "0.3.5"
+termcolor = "1.4"
 thiserror = "1.0.61"
 toml = "0.8"
 

Cargo.toml

@@ -1,5 +1,7 @@
 use std::fmt;
+use std::io::Write;
 
+use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
 use thiserror::Error;
 
 use crate::span::Span;
@@ -45,6 +47,85 @@ impl Error {
         }
     }
 
+    pub fn pretty_print_colored(&self, code: impl Into<String>, no_color: bool) -> String {
+        // Use a string buffer to build the colored output
+        let mut buffer = Vec::new();
+        self.write_colored(&mut buffer, code, no_color).unwrap();
+        String::from_utf8(buffer).unwrap()
+    }
+
+    pub fn write_colored<W: Write>(
+        &self,
+        _writer: &mut W,
+        code: impl Into<String>,
+        no_color: bool,
+    ) -> std::io::Result<()> {
+        let code = code.into();
+
+        // Determine color choice
+        let color_choice = if no_color {
+            ColorChoice::Never
+        } else if atty::is(atty::Stream::Stderr) {
+            ColorChoice::Auto
+        } else {
+            ColorChoice::Never
+        };
+
+        // Only use color if we're writing to a TTY
+        if color_choice == ColorChoice::Auto {
+            let mut stderr = StandardStream::stderr(color_choice);
+
+            // Write error type in red
+            stderr.set_color(ColorSpec::new().set_fg(Some(Color::Red)).set_bold(true))?;
+            write!(&mut stderr, "error")?;
+            stderr.reset()?;
+
+            // Write location info
+            if let Some(span) = self.span() {
+                write!(&mut stderr, ": ")?;
+                stderr.set_color(ColorSpec::new().set_bold(true))?;
+                write!(
+                    &mut stderr,
+                    "{}:{}",
+                    span.line_number(&code),
+                    span.column_number(&code)
+                )?;
+                stderr.reset()?;
+            }
+
+            // Write message
+            write!(&mut stderr, " - {}", self.message())?;
+
+            // Write code snippet with underline
+            if let Some(span) = self.span() {
+                writeln!(&mut stderr)?;
+                let snippet = span.pretty_print(&code);
+
+                // Split the snippet into lines
+                let lines: Vec<&str> = snippet.lines().collect();
+
+                // Write the code line
+                if !lines.is_empty() {
+                    writeln!(&mut stderr, "{}", lines[0])?;
+                }
+
+                // Write the underline in red
+                if lines.len() > 1 {
+                    stderr.set_color(ColorSpec::new().set_fg(Some(Color::Red)).set_bold(true))?;
+                    writeln!(&mut stderr, "{}", lines[1])?;
+                    stderr.reset()?;
+                }
+            } else {
+                writeln!(&mut stderr)?;
+            }
+        } else {
+            // No color - just print plain text
+            eprintln!("{}", self.pretty_print(&code));
+        }
+
+        Ok(())
+    }
+
     fn span(&self) -> Option<&Span> {
         match self {
             Error::Semantic(_, span) => Some(span),

src/error.rs

@@ -12,6 +12,10 @@ struct Cli {
 
     /// Run a hash script
     file: Option<std::path::PathBuf>,
+
+    /// Disable colored output
+    #[clap(long, global = true)]
+    no_color: bool,
 }
 
 #[derive(Parser, Debug)]
@@ -77,6 +81,10 @@ struct Test {
     /// Number of test threads (interpreter mode only)
     #[clap(long, default_value = "1")]
     test_threads: usize,
+
+    /// Disable colored output
+    #[clap(long)]
+    no_color: bool,
 }
 
 #[derive(Subcommand, Debug)]
@@ -108,23 +116,24 @@ struct Compile {
 
 fn main() -> anyhow::Result<()> {
     let cli = Cli::parse();
+    let no_color = cli.no_color;
 
     if let Some(file) = cli.file {
-        return run_command(file);
+        return run_command(file, no_color);
     }
 
     match cli.cmd {
-        Some(Command::Run(run)) => run_command(run.file)?,
-        Some(Command::Compile(compile)) => compile_command(compile)?,
-        Some(Command::Build(build)) => build_command(build)?,
+        Some(Command::Run(run)) => run_command(run.file, no_color)?,
+        Some(Command::Compile(compile)) => compile_command(compile, no_color)?,
+        Some(Command::Build(build)) => build_command(build, no_color)?,
         Some(Command::New(new)) => new_command(new)?,
-        Some(Command::Test(test)) => test_command(test)?,
+        Some(Command::Test(test)) => test_command(test, no_color)?,
         Some(Command::Repl) | None => repl()?,
     };
     Ok(())
 }
 
-fn run_command(file: PathBuf) -> anyhow::Result<()> {
+fn run_command(file: PathBuf, no_color: bool) -> anyhow::Result<()> {
     let code = std::fs::read_to_string(&file)?;
 
     // Determine project root (for now, use parent of src directory if it exists)
@@ -143,15 +152,16 @@ fn run_command(file: PathBuf) -> anyhow::Result<()> {
     match husk::execute_script_with_context(&code, Some(file), project_root) {
         Ok(_) => {}
         Err(e) => {
-            eprintln!("{}", e.pretty_print(code));
+            let mut stderr = Vec::new();
+            e.write_colored(&mut stderr, &code, no_color).unwrap();
             std::process::exit(1);
         }
     }
 
     Ok(())
 }
 
-fn build_command(cli: Build) -> anyhow::Result<()> {
+fn build_command(cli: Build, _no_color: bool) -> anyhow::Result<()> {
     use husk::HuskConfig;
     use std::fs;
 
@@ -268,12 +278,13 @@ fn find_husk_files(dir: &std::path::Path) -> anyhow::Result<Vec<std::path::PathB
     Ok(husk_files)
 }
 
-fn compile_command(cli: Compile) -> anyhow::Result<()> {
+fn compile_command(cli: Compile, no_color: bool) -> anyhow::Result<()> {
     let code = std::fs::read_to_string(cli.file)?;
     match husk::transpile_to_js_with_packages(&code) {
         Ok(js) => println!("{}", js),
         Err(e) => {
-            eprintln!("{}", e.pretty_print(code));
+            let mut stderr = Vec::new();
+            e.write_colored(&mut stderr, &code, no_color).unwrap();
             std::process::exit(1);
         }
     }
@@ -351,7 +362,7 @@ module = "esm"
     Ok(())
 }
 
-fn test_command(cli: Test) -> anyhow::Result<()> {
+fn test_command(cli: Test, no_color: bool) -> anyhow::Result<()> {
     use husk::test_runner::{TestConfig, TestRunner};
     use husk::{Lexer, Parser, SemanticVisitor};
     use std::fs;
@@ -389,19 +400,19 @@ fn test_command(cli: Test) -> anyhow::Result<()> {
         let ast = match parser.parse() {
             Ok(ast) => ast,
             Err(e) => {
-                eprintln!("Parse error in {:?}: {}", file_path, e.pretty_print(code));
+                eprint!("Parse error in {:?}: ", file_path);
+                let mut stderr = Vec::new();
+                e.write_colored(&mut stderr, &code, no_color).unwrap();
                 continue;
             }
         };
 
         // Run semantic analysis with test discovery
         let mut analyzer = SemanticVisitor::new();
         if let Err(e) = analyzer.analyze(&ast) {
-            eprintln!(
-                "Semantic error in {:?}: {}",
-                file_path,
-                e.pretty_print(code)
-            );
+            eprint!("Semantic error in {:?}: ", file_path);
+            let mut stderr = Vec::new();
+            e.write_colored(&mut stderr, &code, no_color).unwrap();
             continue;
         }
 
@@ -429,6 +440,7 @@ fn test_command(cli: Test) -> anyhow::Result<()> {
                 filter: cli.filter.clone(),
                 test_threads: cli.test_threads,
                 show_timing: cli.show_timing,
+                no_color: cli.no_color || no_color,
             };
 
             let runner = TestRunner::new(ast, config);