vibe-action 0.1.5

Command router — execute shell commands and LLM prompts via simple YAML actions.
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

//! Formatting utilities.
//! Converts data into a human-readable string.

use std::time::Duration;

/// Input type for time formatting — either raw milliseconds or a Duration.
pub enum TimeInput {
    Millis(u64),
    Duration(Duration),
}

/// Allows using a u64 (milliseconds) where a TimeInput is expected.
impl From<u64> for TimeInput {
    fn from(ms: u64) -> Self {
        TimeInput::Millis(ms)
    }
}

/// Allows using a Duration where a TimeInput is expected.
impl From<Duration> for TimeInput {
    fn from(d: Duration) -> Self {
        TimeInput::Duration(d)
    }
}

/// Formats a time value into a human-readable string.
/// Uses seconds for values >= 1s, milliseconds for >= 1ms, microseconds otherwise.
pub fn format_duration<T: Into<TimeInput>>(input: T) -> String {
    let duration = match input.into() {
        TimeInput::Millis(ms) => Duration::from_millis(ms),
        TimeInput::Duration(d) => d,
    };

    let secs = duration.as_secs_f64();

    if secs >= 1.0 {
        format!("{:.2}s", secs)
    } else if duration.as_millis() > 0 {
        format!("{}ms", duration.as_millis())
    } else {
        format!("{}µs", duration.as_micros())
    }
}

/// Formats a byte size into a human-readable string.
/// Uses GB for >= 1GB, MB for >= 1MB, KB for >= 1KB, bytes otherwise.
pub fn format_bytes(bytes: usize) -> String {
    if bytes >= 1_000_000_000 {
        format!("{:.1}GB", bytes as f64 / 1_000_000_000.0)
    } else if bytes >= 1_000_000 {
        format!("{:.1}MB", bytes as f64 / 1_000_000.0)
    } else if bytes >= 1_000 {
        format!("{}KB", bytes / 1_000)
    } else {
        format!("{}B", bytes)
    }
}

/// Extract base64 images from resolved prompt text.
/// Returns cleaned prompt and list of extracted images.
pub fn format_image_prompt(prompt: &str) -> (String, Vec<String>) {
    let mut images = Vec::new();
    let mut cleaned = prompt.to_string();
    let prefixes = crate::utils::image::image_base64_prefixes();

    for prefix in prefixes {
        while let Some(pos) = cleaned.find(prefix) {
            let end = cleaned[pos..]
                .find(|c: char| c.is_whitespace())
                .map(|p| pos + p)
                .unwrap_or(cleaned.len());

            images.push(cleaned[pos..end].to_string());
            cleaned.replace_range(pos..end, "");
        }
    }

    (cleaned.trim().to_string(), images)
}