rewrote basic functionality to C. there are no colors just yet

1 files changed, 0 insertions, 617 deletions

diff --git a/src/color.rs b/src/color.rs
deleted file mode 100644
index 74497ab..0000000
--- a/src/color.rs
+++ /dev/null
@@ -1,617 +0,0 @@
-use clap::ValueEnum;
-// No external sysinfo dependency — use environment heuristics instead for Windows shell detection.
-use std::error::Error;
-use std::fmt;
-use std::str::FromStr;
-
-#[derive(Debug, Clone, PartialEq)]
-pub enum Color {
-    Named(NamedColor),
-    Hex(String),
-    Rgb(u8, u8, u8),
-    Hsl(u16, u8, u8),      // h: 0-360, s: 0-100, l: 0-100
-    Ansi(u8),              // ANSI color code (0-255)
-    Truecolor(u8, u8, u8), // 24-bit RGB
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, ValueEnum)]
-pub enum NamedColor {
-    Black,
-    Red,
-    Green,
-    Yellow,
-    Blue,
-    Magenta,
-    Cyan,
-    White,
-    BrightBlack,
-    BrightRed,
-    BrightGreen,
-    BrightYellow,
-    BrightBlue,
-    BrightMagenta,
-    BrightCyan,
-    BrightWhite,
-}
-
-#[derive(Debug)]
-pub enum ColorParseError {
-    InvalidFormat,
-    InvalidHex,
-    InvalidRgb,
-    InvalidHsl,
-    UnknownNamedColor,
-}
-
-impl fmt::Display for ColorParseError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            ColorParseError::InvalidFormat => write!(f, "Invalid color format"),
-            ColorParseError::InvalidHex => write!(f, "Invalid hex color code"),
-            ColorParseError::InvalidRgb => write!(f, "Invalid RGB format. Expected format: R,G,B"),
-            ColorParseError::InvalidHsl => {
-                write!(f, "Invalid HSL format. Expected format: hsl(H,S%,L%)")
-            }
-            ColorParseError::UnknownNamedColor => write!(f, "Unknown named color"),
-        }
-    }
-}
-
-impl Error for ColorParseError {}
-
-impl FromStr for Color {
-    type Err = ColorParseError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let s_lower = s.to_lowercase();
-
-        // Try named color first
-        if let Ok(named) = NamedColor::from_str(s, true) {
-            return Ok(Color::Named(named));
-        }
-
-        // Try hex color (#RRGGBB or #RGB)
-        if s.starts_with('#') {
-            return parse_hex_color(s);
-        }
-
-        // Try HSL (hsl(180,100%,50%))
-        if s_lower.starts_with("hsl(") && s.ends_with(')') {
-            return parse_hsl_color(s);
-        }
-
-        // Try RGB tuple (255,0,128)
-        if s.contains(',') {
-            return parse_rgb_color(s);
-        }
-
-        // Try ANSI code (number between 0-255)
-        if let Ok(code) = s.parse::<u8>() {
-            return Ok(Color::Ansi(code));
-        }
-
-        Err(ColorParseError::InvalidFormat)
-    }
-}
-
-impl FromStr for NamedColor {
-    type Err = ColorParseError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Self::from_str(s, false)
-    }
-}
-
-impl NamedColor {
-    fn from_str(s: &str, ignore_case: bool) -> Result<Self, ColorParseError> {
-        let s = if ignore_case {
-            s.to_lowercase()
-        } else {
-            s.to_string()
-        };
-
-        match s.as_str() {
-            "black" => Ok(NamedColor::Black),
-            "red" => Ok(NamedColor::Red),
-            "green" => Ok(NamedColor::Green),
-            "yellow" => Ok(NamedColor::Yellow),
-            "blue" => Ok(NamedColor::Blue),
-            "magenta" => Ok(NamedColor::Magenta),
-            "cyan" => Ok(NamedColor::Cyan),
-            "white" => Ok(NamedColor::White),
-            "brightblack" | "bright_black" => Ok(NamedColor::BrightBlack),
-            "brightred" | "bright_red" => Ok(NamedColor::BrightRed),
-            "brightgreen" | "bright_green" => Ok(NamedColor::BrightGreen),
-            "brightyellow" | "bright_yellow" => Ok(NamedColor::BrightYellow),
-            "brightblue" | "bright_blue" => Ok(NamedColor::BrightBlue),
-            "brightmagenta" | "bright_magenta" => Ok(NamedColor::BrightMagenta),
-            "brightcyan" | "bright_cyan" => Ok(NamedColor::BrightCyan),
-            "brightwhite" | "bright_white" => Ok(NamedColor::BrightWhite),
-            _ => Err(ColorParseError::UnknownNamedColor),
-        }
-    }
-}
-
-fn parse_hex_color(s: &str) -> Result<Color, ColorParseError> {
-    let hex = s.trim_start_matches('#');
-
-    match hex.len() {
-        3 => {
-            // #RGB format
-            let r = u8::from_str_radix(&hex[0..1].repeat(2), 16)
-                .map_err(|_| ColorParseError::InvalidHex)?;
-            let g = u8::from_str_radix(&hex[1..2].repeat(2), 16)
-                .map_err(|_| ColorParseError::InvalidHex)?;
-            let b = u8::from_str_radix(&hex[2..3].repeat(2), 16)
-                .map_err(|_| ColorParseError::InvalidHex)?;
-            Ok(Color::Hex(format!("#{:02x}{:02x}{:02x}", r, g, b)))
-        }
-        6 => {
-            // #RRGGBB format
-            let r = u8::from_str_radix(&hex[0..2], 16).map_err(|_| ColorParseError::InvalidHex)?;
-            let g = u8::from_str_radix(&hex[2..4], 16).map_err(|_| ColorParseError::InvalidHex)?;
-            let b = u8::from_str_radix(&hex[4..6], 16).map_err(|_| ColorParseError::InvalidHex)?;
-            Ok(Color::Hex(format!("#{:02x}{:02x}{:02x}", r, g, b)))
-        }
-        _ => Err(ColorParseError::InvalidHex),
-    }
-}
-
-fn parse_rgb_color(s: &str) -> Result<Color, ColorParseError> {
-    let parts: Vec<&str> = s.split(',').map(|p| p.trim()).collect();
-    if parts.len() != 3 {
-        return Err(ColorParseError::InvalidRgb);
-    }
-
-    let r = parts[0]
-        .parse::<u8>()
-        .map_err(|_| ColorParseError::InvalidRgb)?;
-    let g = parts[1]
-        .parse::<u8>()
-        .map_err(|_| ColorParseError::InvalidRgb)?;
-    let b = parts[2]
-        .parse::<u8>()
-        .map_err(|_| ColorParseError::InvalidRgb)?;
-
-    Ok(Color::Rgb(r, g, b))
-}
-
-fn parse_hsl_color(s: &str) -> Result<Color, ColorParseError> {
-    let content = s.trim_start_matches("hsl(").trim_end_matches(')');
-    let parts: Vec<&str> = content.split(',').map(|p| p.trim()).collect();
-
-    if parts.len() != 3 {
-        return Err(ColorParseError::InvalidHsl);
-    }
-
-    let h = parts[0]
-        .trim_end_matches(|c: char| !c.is_ascii_digit())
-        .parse::<u16>()
-        .map_err(|_| ColorParseError::InvalidHsl)?;
-    let s = parts[1]
-        .trim_end_matches('%')
-        .parse::<u8>()
-        .map_err(|_| ColorParseError::InvalidHsl)?;
-    let l = parts[2]
-        .trim_end_matches('%')
-        .parse::<u8>()
-        .map_err(|_| ColorParseError::InvalidHsl)?;
-
-    if h > 360 || s > 100 || l > 100 {
-        return Err(ColorParseError::InvalidHsl);
-    }
-
-    Ok(Color::Hsl(h, s, l))
-}
-
-impl Color {
-    /// Convert color to RGB tuple
-    pub fn to_rgb(&self) -> (u8, u8, u8) {
-        match self {
-            Color::Named(named) => named.to_rgb(),
-            Color::Hex(hex) => {
-                let hex = hex.trim_start_matches('#');
-                match hex.len() {
-                    3 => {
-                        // #RGB format
-                        let r = u8::from_str_radix(&hex[0..1].repeat(2), 16).unwrap_or(0);
-                        let g = u8::from_str_radix(&hex[1..2].repeat(2), 16).unwrap_or(0);
-                        let b = u8::from_str_radix(&hex[2..3].repeat(2), 16).unwrap_or(0);
-                        (r, g, b)
-                    }
-                    6 => {
-                        // #RRGGBB format
-                        let r = u8::from_str_radix(&hex[0..2], 16).unwrap_or(0);
-                        let g = u8::from_str_radix(&hex[2..4], 16).unwrap_or(0);
-                        let b = u8::from_str_radix(&hex[4..6], 16).unwrap_or(0);
-                        (r, g, b)
-                    }
-                    _ => (0, 0, 0),
-                }
-            }
-            Color::Rgb(r, g, b) => (*r, *g, *b),
-            Color::Hsl(h, s, l) => hsl_to_rgb(*h, *s, *l),
-            Color::Ansi(code) => ansi_to_rgb(*code),
-            Color::Truecolor(r, g, b) => (*r, *g, *b),
-        }
-    }
-
-    /// Convert color to ANSI escape code for foreground
-    pub fn to_ansi_fg(&self, color_mode: ColorMode) -> String {
-        match color_mode {
-            ColorMode::Truecolor => self.to_truecolor_fg(),
-            ColorMode::Ansi256 => self.to_ansi256_fg(),
-            ColorMode::Ansi16 => self.to_ansi16_fg(),
-            ColorMode::NoColor => "".to_string(),
-        }
-    }
-
-    fn to_truecolor_fg(&self) -> String {
-        let (r, g, b) = self.to_rgb();
-        format!("\x1b[38;2;{};{};{}m", r, g, b)
-    }
-
-    fn to_ansi256_fg(&self) -> String {
-        let (r, g, b) = self.to_rgb();
-        let code = rgb_to_ansi256(r, g, b);
-        format!("\x1b[38;5;{}m", code)
-    }
-
-    fn to_ansi16_fg(&self) -> String {
-        let (r, g, b) = self.to_rgb();
-        let code = rgb_to_ansi16(r, g, b);
-        format!("\x1b[{}m", code)
-    }
-}
-
-impl NamedColor {
-    pub fn to_rgb(self) -> (u8, u8, u8) {
-        match self {
-            NamedColor::Black => (0, 0, 0),
-            NamedColor::Red => (197, 15, 31),
-            NamedColor::Green => (19, 161, 14),
-            NamedColor::Yellow => (193, 156, 0),
-            NamedColor::Blue => (0, 55, 218),
-            NamedColor::Magenta => (136, 23, 152),
-            NamedColor::Cyan => (58, 150, 221),
-            NamedColor::White => (204, 204, 204),
-            NamedColor::BrightBlack => (118, 118, 118),
-            NamedColor::BrightRed => (231, 72, 86),
-            NamedColor::BrightGreen => (22, 198, 12),
-            NamedColor::BrightYellow => (249, 241, 165),
-            NamedColor::BrightBlue => (59, 120, 255),
-            NamedColor::BrightMagenta => (180, 0, 158),
-            NamedColor::BrightCyan => (97, 214, 214),
-            NamedColor::BrightWhite => (242, 242, 242),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum ColorMode {
-    Truecolor,
-    Ansi256,
-    Ansi16,
-    NoColor,
-}
-
-/// Convert HSL to RGB
-fn hsl_to_rgb(h: u16, s: u8, l: u8) -> (u8, u8, u8) {
-    let h = h as f32 / 360.0;
-    let s = s as f32 / 100.0;
-    let l = l as f32 / 100.0;
-
-    let (r, g, b) = if s == 0.0 {
-        (l, l, l)
-    } else {
-        let hue_to_rgb = |p: f32, q: f32, t: f32| -> f32 {
-            let mut t = t;
-            if t < 0.0 {
-                t += 1.0;
-            }
-            if t > 1.0 {
-                t -= 1.0;
-            }
-            if t < 1.0 / 6.0 {
-                return p + (q - p) * 6.0 * t;
-            }
-            if t < 1.0 / 2.0 {
-                return q;
-            }
-            if t < 2.0 / 3.0 {
-                return p + (q - p) * (2.0 / 3.0 - t) * 6.0;
-            }
-            p
-        };
-
-        let q = if l < 0.5 {
-            l * (1.0 + s)
-        } else {
-            l + s - l * s
-        };
-        let p = 2.0 * l - q;
-
-        (
-            hue_to_rgb(p, q, h + 1.0 / 3.0),
-            hue_to_rgb(p, q, h),
-            hue_to_rgb(p, q, h - 1.0 / 3.0),
-        )
-    };
-
-    (
-        (r * 255.0).round() as u8,
-        (g * 255.0).round() as u8,
-        (b * 255.0).round() as u8,
-    )
-}
-
-/// Convert RGB to ANSI 256 color code
-fn rgb_to_ansi256(r: u8, g: u8, b: u8) -> u8 {
-    // Calculate grayscale value
-    let gray = (r as f32 * 0.299 + g as f32 * 0.587 + b as f32 * 0.114).round() as u8;
-
-    // Check if it's a grayscale color
-    if r == g && g == b {
-        // Grayscale ramp (232-255)
-        if gray <= 8 {
-            16
-        } else if gray >= 248 {
-            231
-        } else {
-            ((gray as f32 - 8.0) / 247.0 * 24.0).round() as u8 + 232
-        }
-    } else {
-        // Color cube (16-231)
-        let r = (r as f32 / 255.0 * 5.0).round() as u8;
-        let g = (g as f32 / 255.0 * 5.0).round() as u8;
-        let b = (b as f32 / 255.0 * 5.0).round() as u8;
-
-        16 + (r * 36) + (g * 6) + b
-    }
-}
-
-/// Convert RGB to ANSI 16 color code
-pub(crate) fn rgb_to_ansi16(r: u8, g: u8, b: u8) -> u8 {
-    // Calculate brightness (perceived luminance)
-    let brightness = (r as f32 * 0.299 + g as f32 * 0.587 + b as f32 * 0.114).round() as u8;
-    let is_bright = brightness > 128;
-
-    // Determine base color using simple thresholding on each channel, producing an index 0..7
-    let r_on = r > 128;
-    let g_on = g > 128;
-    let b_on = b > 128;
-    let base_idx = (r_on as u8) + (g_on as u8) * 2 + (b_on as u8) * 4; // 0..7
-
-    // SGR color codes: 30..37 for normal, 90..97 for bright
-    if is_bright {
-        90 + base_idx
-    } else {
-        30 + base_idx
-    }
-}
-
-/// Convert ANSI color code to RGB
-fn ansi_to_rgb(code: u8) -> (u8, u8, u8) {
-    match code {
-        // Standard 16 colors
-        0 => (0, 0, 0),        // Black
-        1 => (128, 0, 0),      // Red
-        2 => (0, 128, 0),      // Green
-        3 => (128, 128, 0),    // Yellow
-        4 => (0, 0, 128),      // Blue
-        5 => (128, 0, 128),    // Magenta
-        6 => (0, 128, 128),    // Cyan
-        7 => (192, 192, 192),  // White
-        8 => (128, 128, 128),  // Bright Black
-        9 => (255, 0, 0),      // Bright Red
-        10 => (0, 255, 0),     // Bright Green
-        11 => (255, 255, 0),   // Bright Yellow
-        12 => (0, 0, 255),     // Bright Blue
-        13 => (255, 0, 255),   // Bright Magenta
-        14 => (0, 255, 255),   // Bright Cyan
-        15 => (255, 255, 255), // Bright White
-
-        // 256-color mode
-        16..=231 => {
-            // Color cube
-            let code = code - 16;
-            let r = ((code / 36) % 6) * 51;
-            let g = ((code / 6) % 6) * 51;
-            let b = (code % 6) * 51;
-            (r, g, b)
-        }
-
-        232..=255 => {
-            // Grayscale ramp
-            let gray = (code - 232) * 10 + 8;
-            (gray, gray, gray)
-        }
-    }
-}
-
-// (Removed older detect_color_mode to keep a single refactored implementation)
-
-/// Try to enable ANSI (virtual terminal processing) on Windows consoles.
-/// Returns true if enabling succeeded or isn't necessary, false otherwise.
-#[cfg(windows)]
-pub fn enable_windows_ansi() -> bool {
-    // no ptr usage required; removed unused import
-    use winapi::um::consoleapi::{GetConsoleMode, SetConsoleMode};
-    use winapi::um::handleapi::INVALID_HANDLE_VALUE;
-    use winapi::um::processenv::GetStdHandle;
-    use winapi::um::winbase::STD_OUTPUT_HANDLE;
-    use winapi::um::wincon::ENABLE_VIRTUAL_TERMINAL_PROCESSING;
-
-    unsafe {
-        let stdout = GetStdHandle(STD_OUTPUT_HANDLE);
-        if stdout == INVALID_HANDLE_VALUE {
-            return false;
-        }
-
-        let mut mode: u32 = 0;
-        if GetConsoleMode(stdout, &mut mode) == 0 {
-            return false;
-        }
-
-        let new_mode = mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING;
-        if SetConsoleMode(stdout, new_mode) == 0 {
-            return false;
-        }
-    }
-
-    true
-}
-
-/// Detect the parent shell name on Windows, using environment hints.
-#[cfg(windows)]
-pub fn detect_windows_shell() -> Option<String> {
-    // Heuristic checks using common env vars
-    if std::env::var("PSModulePath").is_ok() {
-        return Some("powershell".to_string());
-    }
-    if std::env::var("PWshPROFILE").is_ok() || std::env::var("PWSH_VERSION").is_ok() {
-        return Some("pwsh".to_string());
-    }
-    if let Ok(comspec) = std::env::var("COMSPEC") {
-        if comspec.to_lowercase().ends_with("cmd.exe") {
-            return Some("cmd.exe".to_string());
-        }
-    }
-    if std::env::var("WT_SESSION").is_ok() {
-        return Some("windows_terminal".to_string());
-    }
-    None
-}
-
-#[cfg(not(windows))]
-#[allow(dead_code)]
-pub fn detect_windows_shell() -> Option<String> {
-    None
-}
-
-/// Detect the parent shell name on Windows, using the sysinfo crate.
-pub fn detect_color_mode() -> ColorMode {
-    if std::env::var("NO_COLOR").is_ok() {
-        return ColorMode::NoColor;
-    }
-
-    // Early checks
-    if std::env::var("COLORTERM")
-        .is_ok_and(|colorterm| colorterm.contains("truecolor") || colorterm.contains("24bit"))
-    {
-        return ColorMode::Truecolor;
-    }
-
-    if std::env::var("TERM").is_ok_and(|term| term.contains("256color")) {
-        return ColorMode::Ansi256;
-    }
-    if std::env::var("TERM").is_ok_and(|term| term.contains("color")) {
-        return ColorMode::Ansi16;
-    }
-
-    // Default fallback
-    #[cfg(windows)]
-    let mut mode = ColorMode::Ansi16;
-    #[cfg(not(windows))]
-    let mode = ColorMode::Ansi16;
-
-    // If running on Windows, try to enable ANSI (virtual terminal processing)
-    #[cfg(windows)]
-    {
-        if enable_windows_ansi() {
-            // Re-check for a better mode
-            if let Ok(colorterm) = std::env::var("COLORTERM") {
-                if colorterm.contains("truecolor") || colorterm.contains("24bit") {
-                    mode = ColorMode::Truecolor;
-                }
-            }
-            if let Ok(term) = std::env::var("TERM") {
-                if term.contains("256color") {
-                    mode = ColorMode::Ansi256;
-                }
-            }
-        } else if let Some(shell) = detect_windows_shell() {
-            let shell = shell.to_lowercase();
-            if shell.contains("cmd.exe") {
-                // cmd historically doesn't support ANSI; use 16 colors fallback
-                mode = ColorMode::Ansi16;
-            } else if shell.contains("powershell") || shell.contains("pwsh") {
-                if let Ok(term) = std::env::var("TERM") {
-                    if term.contains("256color") {
-                        mode = ColorMode::Ansi256;
-                    }
-                }
-            } else {
-                mode = ColorMode::Ansi16;
-            }
-        }
-    }
-
-    mode
-}
-
-/// Convert RGB to HSV
-fn rgb_to_hsv((r, g, b): (u8, u8, u8)) -> (f32, f32, f32) {
-    let r = r as f32 / 255.0;
-    let g = g as f32 / 255.0;
-    let b = b as f32 / 255.0;
-
-    let max = r.max(g).max(b);
-    let min = r.min(g).min(b);
-    let delta = max - min;
-
-    let h = if delta == 0.0 {
-        0.0
-    } else if max == r {
-        60.0 * (((g - b) / delta) % 6.0)
-    } else if max == g {
-        60.0 * (((b - r) / delta) + 2.0)
-    } else {
-        60.0 * (((r - g) / delta) + 4.0)
-    };
-
-    let h = if h < 0.0 { h + 360.0 } else { h };
-
-    let s = if max == 0.0 { 0.0 } else { delta / max };
-    let v = max;
-
-    (h, s, v)
-}
-
-/// Linear interpolation between two colors in HSV space
-pub fn lerp_color_hsv(start: &Color, end: &Color, t: f32) -> Color {
-    let (h1, s1, v1) = rgb_to_hsv(start.to_rgb());
-    let (h2, s2, v2) = rgb_to_hsv(end.to_rgb());
-
-    // Handle hue interpolation correctly (shortest path around the color wheel)
-    let h_diff = (h2 - h1 + 180.0) % 360.0 - 180.0;
-    let h = (h1 + h_diff * t + 360.0) % 360.0;
-
-    let s = s1 + (s2 - s1) * t;
-    let v = v1 + (v2 - v1) * t;
-
-    let (r, g, b) = hsv_to_rgb(h, s, v);
-    Color::Truecolor(r, g, b)
-}
-
-/// Convert HSV to RGB
-fn hsv_to_rgb(h: f32, s: f32, v: f32) -> (u8, u8, u8) {
-    let c = v * s;
-    let x = c * (1.0 - ((h / 60.0) % 2.0 - 1.0).abs());
-    let m = v - c;
-
-    let (r, g, b) = match h {
-        h if (0.0..60.0).contains(&h) => (c, x, 0.0),
-        h if (60.0..120.0).contains(&h) => (x, c, 0.0),
-        h if (120.0..180.0).contains(&h) => (0.0, c, x),
-        h if (180.0..240.0).contains(&h) => (0.0, x, c),
-        h if (240.0..300.0).contains(&h) => (x, 0.0, c),
-        _ => (c, 0.0, x),
-    };
-
-    (
-        ((r + m) * 255.0).round() as u8,
-        ((g + m) * 255.0).round() as u8,
-        ((b + m) * 255.0).round() as u8,
-    )
-}