vtcode 0.99.1

A Rust-based terminal coding agent with modular architecture supporting multiple LLM providers
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

use anstyle::Style as AnsiStyle;
use anyhow::Result;
use vtcode_core::utils::ansi::{AnsiRenderer, MessageStyle};

#[derive(Clone)]
pub(crate) struct PanelContentLine {
    pub(crate) rendered: String,
    pub(crate) style: MessageStyle,
    pub(crate) override_style: Option<AnsiStyle>,
}

impl PanelContentLine {
    pub(crate) fn new(text: impl Into<String>, style: MessageStyle) -> Self {
        Self {
            rendered: text.into(),
            style,
            override_style: None,
        }
    }
}

pub(crate) fn render_left_border_panel(
    renderer: &mut AnsiRenderer,
    lines: Vec<PanelContentLine>,
) -> Result<()> {
    for line in lines {
        if let Some(override_style) = line.override_style {
            renderer.line_with_override_style(
                line.style,
                override_style,
                line.rendered.as_str(),
            )?;
        } else {
            renderer.line(line.style, line.rendered.as_str())?;
        }
    }

    Ok(())
}

#[cfg(test)]
pub(crate) fn wrap_text(text: &str, width: usize) -> Vec<String> {
    if width == 0 {
        return vec![text.to_string()];
    }

    let mut lines = Vec::new();
    let mut current_line = String::new();

    for word in text.split_whitespace() {
        let word_len = word.chars().count();

        if !current_line.is_empty() {
            let current_visible = current_line
                .chars()
                .filter(|ch| !ch.is_whitespace())
                .count();

            if current_visible + word_len > width {
                lines.push(current_line);
                current_line = String::new();
            }
        }

        if word_len > width {
            if !current_line.is_empty() {
                lines.push(current_line);
                current_line = String::new();
            }

            let mut remaining = word;
            while !remaining.is_empty() {
                let mut byte_len = remaining.len();

                for (chars_taken, (idx, ch)) in remaining.char_indices().enumerate() {
                    if chars_taken == width {
                        byte_len = idx;
                        break;
                    }
                    byte_len = idx + ch.len_utf8();
                }

                let chunk = &remaining[..byte_len];
                lines.push(chunk.to_string());
                remaining = &remaining[byte_len..];
            }
        } else {
            if !current_line.is_empty() {
                current_line.push(' ');
            }
            current_line.push_str(word);
        }
    }

    if !current_line.is_empty() {
        lines.push(current_line);
    }

    if lines.is_empty() {
        lines.push(text.to_string());
    }

    lines
}

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

    #[test]
    fn test_wrap_text() {
        let result = wrap_text("Hello world this is a long text", 10);
        assert_eq!(result, vec!["Hello world", "this is a", "long text"]);

        let result = wrap_text("supercalifragilisticexpialidocious", 10);
        assert_eq!(
            result,
            vec!["supercalif", "ragilistic", "expialidoc", "ious",]
        );

        let result = wrap_text("", 10);
        assert_eq!(result, vec!["".to_string()]);

        let result = wrap_text("Hello", 10);
        assert_eq!(result, vec!["Hello"]);
    }
}