mise 2026.8.9

Dev tools, env vars, and tasks in one CLI
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use std::path::Path;
use std::sync::LazyLock;

use crate::file::display_path;
use console::{Color, Style, StyledObject, style};

pub fn estyle<D>(val: D) -> StyledObject<D> {
    style(val).for_stderr()
}

pub fn ecyan<D>(val: D) -> StyledObject<D> {
    estyle(val).cyan()
}

pub fn eblue<D>(val: D) -> StyledObject<D> {
    estyle(val).blue()
}

pub fn emagenta<D>(val: D) -> StyledObject<D> {
    estyle(val).magenta()
}

pub fn egreen<D>(val: D) -> StyledObject<D> {
    estyle(val).green()
}

pub fn eyellow<D>(val: D) -> StyledObject<D> {
    estyle(val).yellow()
}

pub fn ered<D>(val: D) -> StyledObject<D> {
    estyle(val).red()
}

pub fn eblack<D>(val: D) -> StyledObject<D> {
    estyle(val).black()
}

pub fn eunderline<D>(val: D) -> StyledObject<D> {
    estyle(val).underlined()
}

pub fn edim<D>(val: D) -> StyledObject<D> {
    estyle(val).dim()
}

pub fn ebold<D>(val: D) -> StyledObject<D> {
    estyle(val).bold()
}

pub fn nbold<D>(val: D) -> StyledObject<D> {
    nstyle(val).bold()
}

pub fn epath(path: &Path) -> StyledObject<String> {
    estyle(display_path(path))
}

pub fn nstyle<D>(val: D) -> StyledObject<D> {
    style(val).for_stdout()
}

pub fn ncyan<D>(val: D) -> StyledObject<D> {
    nstyle(val).cyan()
}

pub fn nunderline<D>(val: D) -> StyledObject<D> {
    nstyle(val).underlined()
}

pub fn nyellow<D>(val: D) -> StyledObject<D> {
    nstyle(val).yellow()
}

pub fn nred<D>(val: D) -> StyledObject<D> {
    nstyle(val).red()
}

pub fn ndim<D>(val: D) -> StyledObject<D> {
    nstyle(val).dim()
}

pub fn nbright<D>(val: D) -> StyledObject<D> {
    nstyle(val).bright()
}

fn prefix_style(hash_key: impl AsRef<str>, stderr: bool) -> Style {
    static COLORS: LazyLock<Vec<Color>> =
        LazyLock::new(|| vec![Color::Blue, Color::Magenta, Color::Cyan, Color::Green]);

    let hash = hash_key.as_ref().chars().map(|c| c as usize).sum::<usize>();
    let styled = Style::new().fg(COLORS[hash % COLORS.len()]);
    let mut styled = if stderr {
        styled.for_stderr()
    } else {
        styled.for_stdout()
    };
    match (hash / COLORS.len()) % 4 {
        1 => styled = styled.bold(),
        2 => styled = styled.dim(),
        3 => styled = styled.bright(),
        _ => {}
    }

    styled
}

pub fn prefix(label: impl Into<String>, hash_key: impl AsRef<str>, stderr: bool) -> String {
    prefix_style(hash_key, stderr)
        .apply_to(label.into())
        .to_string()
}

/// Return the ANSI sequence that starts the style used for a task prefix.
///
/// Styling is forced here because the caller separately decides whether color
/// is enabled for the selected output mode. The trailing reset emitted by
/// `console` is removed so tasks can apply the style to their own output.
pub fn prefix_ansi(hash_key: impl AsRef<str>) -> String {
    let rendered = prefix_style(hash_key, false)
        .force_styling(true)
        .apply_to("")
        .to_string();
    rendered
        .strip_suffix("\x1b[0m")
        .expect("forced prefix style should end with an ANSI reset")
        .to_string()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn prefix_ansi_matches_rendered_prefix_style() {
        for name in ["a", "b", "c", "d", "alpha", "bravo", "charlie", "echo"] {
            let ansi = prefix_ansi(name);
            let rendered = prefix_style(name, false)
                .force_styling(true)
                .apply_to("label")
                .to_string();
            assert_eq!(rendered, format!("{ansi}label\x1b[0m"));
        }
    }

    #[test]
    fn prefix_ansi_includes_color_and_emphasis() {
        assert_eq!(prefix_ansi("p"), "\x1b[34m");
        assert_eq!(prefix_ansi("a"), "\x1b[35m");
        assert_eq!(prefix_ansi("b"), "\x1b[36m");
        assert_eq!(prefix_ansi("c"), "\x1b[32m");
        assert_eq!(prefix_ansi("alpha"), "\x1b[36m\x1b[1m");
        assert_eq!(prefix_ansi("bravo"), "\x1b[36m\x1b[2m");
        assert_eq!(prefix_ansi("echo"), "\x1b[38;5;10m");
    }
}