supercode-frontend-tui 0.5.79

Attachable terminal frontend primitives for Volter Harness SDK runtimes.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

// Derived from OpenAI Codex: codex-rs/tui/src/terminal_palette.rs
// Pinned source: 8604689ec5e3437eb79802d8d72249b7722fbf5b
// Copyright 2025 OpenAI
// Licensed under the Apache License, Version 2.0.
// Modified by the Supercode contributors; see docs/legal/codex-frontend-extraction.toml.

//! Deterministic terminal color degradation without donor runtime detection.

use ratatui::style::Color;

use crate::foundation::color::perceptual_distance;

/// Color fidelity the active terminal can display safely.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ColorLevel {
    /// 24-bit RGB colors.
    TrueColor,
    /// Xterm's stable 240-color cube and grayscale range.
    Ansi256,
    /// No authored colors; use the terminal defaults.
    Monochrome,
}

/// Explicit inputs used to resolve terminal color behavior.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct ColorCapabilities {
    pub level: ColorLevel,
    pub color_enabled: bool,
}

impl ColorCapabilities {
    /// Resolve capabilities from environment values supplied by the caller.
    ///
    /// Passing values explicitly keeps snapshots deterministic and avoids
    /// mutating process-global environment variables in parallel tests.
    pub fn resolve(
        no_color: bool,
        term: Option<&str>,
        colorterm: Option<&str>,
        force_color: bool,
    ) -> Self {
        if no_color && !force_color {
            return Self::monochrome();
        }
        if term.is_some_and(|value| value.eq_ignore_ascii_case("dumb")) && !force_color {
            return Self::monochrome();
        }

        let truecolor = colorterm.is_some_and(|value| {
            value.eq_ignore_ascii_case("truecolor") || value.eq_ignore_ascii_case("24bit")
        });
        let ansi256 = term.is_some_and(|value| value.to_ascii_lowercase().contains("256color"));
        let level = if truecolor {
            ColorLevel::TrueColor
        } else if ansi256 || force_color {
            ColorLevel::Ansi256
        } else {
            ColorLevel::Monochrome
        };
        Self {
            level,
            color_enabled: level != ColorLevel::Monochrome,
        }
    }

    pub const fn monochrome() -> Self {
        Self {
            level: ColorLevel::Monochrome,
            color_enabled: false,
        }
    }

    /// Return the closest safe Ratatui color for these capabilities.
    pub fn best_color(self, target: (u8, u8, u8)) -> Color {
        match self.level {
            ColorLevel::TrueColor => Color::Rgb(target.0, target.1, target.2),
            ColorLevel::Ansi256 => Color::Indexed(nearest_xterm_index(target)),
            ColorLevel::Monochrome => Color::Reset,
        }
    }
}

fn nearest_xterm_index(target: (u8, u8, u8)) -> u8 {
    xterm_fixed_colors()
        .min_by(|(_, left), (_, right)| {
            perceptual_distance(*left, target)
                .partial_cmp(&perceptual_distance(*right, target))
                .unwrap_or(std::cmp::Ordering::Equal)
        })
        .map_or(16, |(index, _)| index)
}

fn xterm_fixed_colors() -> impl Iterator<Item = (u8, (u8, u8, u8))> {
    let cube = (0u8..6).flat_map(|r| {
        (0u8..6).flat_map(move |g| {
            (0u8..6).map(move |b| {
                let index = 16 + 36 * r + 6 * g + b;
                (
                    index,
                    (xterm_component(r), xterm_component(g), xterm_component(b)),
                )
            })
        })
    });
    let grayscale = (0u8..24).map(|offset| {
        let value = 8 + offset * 10;
        (232 + offset, (value, value, value))
    });
    cube.chain(grayscale)
}

const fn xterm_component(value: u8) -> u8 {
    if value == 0 {
        0
    } else {
        55 + value * 40
    }
}