refactor: introduce utils crate and remove external regex dependency (#266)

Create a new `utils` crate to centralize utility functions and remove
the heavy `regex` dependency, replacing it with a custom lightweight
placeholder parser. Also integrates the `colorex` module.

Changes:
- **New Crate `utils`**:
  - Added `utils/src/colorex.rs`: Custom color formatting logic (moved from `colorex` crate or inline).
  - Added `utils/src/formatx.rs`: Implements `count_placeholders` to replace regex usage for `{}` counting.
  - Updated workspace `Cargo.toml` to include `utils`.
- **Dependency Removal**:
  - Removed `regex` from `front/parser/Cargo.toml`.
  - Replaced `regex::Regex` usage in `front/parser/src/parser/io.rs` with `utils::formatx::count_placeholders`.
- **Integration**:
  - Updated `front/error/Cargo.toml` and `Cargo.toml` to depend on `utils`.
  - Updated `src/main.rs`, `src/lib.rs`, and `front/error/src/error.rs` to use `utils::colorex`.
- **Cleanup**:
  - Removed placeholder `lib.rs` content in `utils`.

This change significantly reduces compilation time and binary size by
eliminating the regex engine dependency.

Signed-off-by: LunaStev <luna@lunastev.org>

Author: LunaStev

Cargo.toml

@@ -13,7 +13,7 @@ path = "src/lib.rs"
 # linker = "clang"
 
 [dependencies]
-colorex = "0.1.0"
+utils = { path = "utils" }
 lexer = { path = "front/lexer" }
 parser = { path = "front/parser" }
 error = { path = "front/error" }
@@ -25,5 +25,6 @@ members = [
     "front/parser",
     "llvm_temporary",
     "front/error",
+    "utils",
     ".",
 ]

front/error/Cargo.toml

@@ -4,4 +4,4 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-colorex = "0.1.1"
+utils = { path = "../../utils" }

front/error/src/error.rs

@@ -178,7 +178,7 @@ impl WaveError {
 
     /// Display error in Rust-style format
     pub fn display(&self) {
-        use colorex::Colorize;
+        use utils::colorex::*;
 
         let severity_str = match self.severity {
             ErrorSeverity::Error => "error".color("255,71,71").bold(),

front/lexer/Cargo.toml

@@ -3,4 +3,3 @@ name = "lexer"
 version = "0.1.0"
 edition = "2021"
 
-[dependencies]

front/parser/Cargo.toml

@@ -6,4 +6,4 @@ edition = "2021"
 [dependencies]
 lexer = { path = "../lexer" }
 error = { path = "../error" }
-regex = "1.11.1"
+utils = { path = "../../utils" }

front/parser/src/parser/io.rs

@@ -1,6 +1,6 @@
 use std::iter::Peekable;
 use std::slice::Iter;
-use regex::Regex;
+use utils::formatx::*;
 use lexer::Token;
 use lexer::token::TokenType;
 use crate::ast::{ASTNode, StatementNode};
@@ -25,10 +25,7 @@ pub fn parse_println(tokens: &mut Peekable<Iter<Token>>) -> Option<ASTNode> {
         return None;
     };
 
-    let placeholder_count = Regex::new(r"\{[^}]*\}")
-        .unwrap()
-        .find_iter(&content)
-        .count();
+    let placeholder_count = count_placeholders(&content);
 
     if placeholder_count == 0 {
         if tokens.peek()?.token_type != TokenType::Rparen {
@@ -110,10 +107,7 @@ pub fn parse_print(tokens: &mut Peekable<Iter<Token>>) -> Option<ASTNode> {
         return None;
     };
 
-    let placeholder_count = Regex::new(r"\{[^}]*\}")
-        .unwrap()
-        .find_iter(&content)
-        .count();
+    let placeholder_count = count_placeholders(&content);
 
     if placeholder_count == 0 {
         // No format → Print just a string
@@ -195,10 +189,7 @@ pub fn parse_input(tokens: &mut Peekable<Iter<Token>>) -> Option<ASTNode> {
         return None;
     };
 
-    let placeholder_count = Regex::new(r"\{[^}]*\}")
-        .unwrap()
-        .find_iter(&content)
-        .count();
+    let placeholder_count = count_placeholders(&content);
 
     let mut args = Vec::new();
     while let Some(Token {

src/lib.rs

@@ -4,7 +4,7 @@ pub mod runner;
 pub mod version;
 
 use crate::version::get_os_pretty_name;
-use colorex::Colorize;
+use utils::colorex::*;
 use std::path::Path;
 
 use commands::DebugFlags;

src/main.rs

@@ -1,7 +1,7 @@
 use std::path::Path;
 use std::{env, process};
 
-use colorex::Colorize;
+use utils::colorex::*;
 use wavec::commands::{handle_build, handle_run, DebugFlags};
 use wavec::errors::CliError;
 use wavec::version_wave;

utils/Cargo.toml

@@ -0,0 +1,4 @@
+[package]
+name = "utils"
+version = "0.1.0"
+edition = "2021"

utils/src/colorex.rs

@@ -0,0 +1,92 @@
+pub struct Color(u8, u8, u8);
+
+impl Color {
+    pub fn from_rgb(rgb: &str) -> Result<Color, &'static str> {
+        let parts: Vec<&str> = rgb.split(',').collect();
+        if parts.len() == 3 {
+            let r = parts[0].parse::<u8>().map_err(|_| "Invalid RGB format")?;
+            let g = parts[1].parse::<u8>().map_err(|_| "Invalid RGB format")?;
+            let b = parts[2].parse::<u8>().map_err(|_| "Invalid RGB format")?;
+            Ok(Color(r, g, b))
+        } else {
+            Err("Invalid RGB format")
+        }
+    }
+
+    pub fn from_hex(hex: &str) -> Result<Color, &'static str> {
+        if hex.len() != 7 || !hex.starts_with('#') {
+            return Err("Invalid HEX format");
+        }
+
+        let r = u8::from_str_radix(&hex[1..3], 16).map_err(|_| "Invalid HEX value")?;
+        let g = u8::from_str_radix(&hex[3..5], 16).map_err(|_| "Invalid HEX value")?;
+        let b = u8::from_str_radix(&hex[5..7], 16).map_err(|_| "Invalid HEX value")?;
+
+        Ok(Color(r, g, b))
+    }
+}
+
+pub trait Colorize {
+    fn color(self, color: &str) -> String;
+    fn bg_color(self, color: &str) -> String;
+    fn bold(self) -> String;
+    fn italic(self) -> String;
+    fn underline(self) -> String;
+    fn strikethrough(self) -> String;
+    fn dim(self) -> String;
+    fn invert(self) -> String;
+}
+
+impl Colorize for &str {
+    fn color(self, color: &str) -> String {
+        let color = if color.starts_with('#') {
+            Color::from_hex(color)
+        } else {
+            Color::from_rgb(color)
+        };
+
+        match color {
+            Ok(c) => format!("\x1b[38;2;{};{};{}m{}\x1b[0m", c.0, c.1, c.2, self),
+            Err(_) => self.to_string(),
+        }
+    }
+
+    fn bg_color(self, color: &str) -> String {
+        let color = if color.starts_with('#') {
+            Color::from_hex(color)
+        } else {
+            Color::from_rgb(color)
+        };
+
+        match color {
+            Ok(c) => format!("\x1b[48;2;{};{};{}m{}\x1b[0m", c.0, c.1, c.2, self),
+            Err(_) => self.to_string(),
+        }
+    }
+
+    fn bold(self) -> String {
+        format!("\x1b[1m{}\x1b[0m", self)
+    }
+
+    fn italic(self) -> String {
+        format!("\x1b[3m{}\x1b[0m", self)
+    }
+
+    fn underline(self) -> String {
+        format!("\x1b[4m{}\x1b[0m", self)
+    }
+
+    fn strikethrough(self) -> String {
+        format!("\x1b[9m{}\x1b[0m", self)
+    }
+
+    fn dim(self) -> String {
+        format!("\x1b[2m{}\x1b[0m", self)
+    }
+
+    fn invert(self) -> String {
+        format!("\x1b[7m{}\x1b[0m", self)
+    }
+}
+
+