rho-coding-agent 0.21.0

A lightweight agent harness inspired by Pi
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 super::table::markdown_table_cells;
use super::*;
use ratatui::{style::Modifier, text::Line};

fn line_text(line: &Line<'_>) -> String {
    line.spans
        .iter()
        .map(|span| span.content.as_ref())
        .collect()
}

#[test]
fn renders_markdown_tables_with_alignment_and_inline_styles() {
    let mut in_code_block = false;
    let lines = markdown_lines(
        "| Name | Count | Note |\n| :--- | ---: | :---: |\n| **alpha** | 2 | `ready` |\n| beta | 12 | waiting |",
        40,
        &mut in_code_block,
    );

    assert_eq!(
        lines.iter().map(line_text).collect::<Vec<_>>(),
        vec![
            "┌───────┬───────┬─────────┐",
            "│ Name  │ Count │  Note   │",
            "├───────┼───────┼─────────┤",
            "│ alpha │     2 │  ready  │",
            "│ beta  │    12 │ waiting │",
            "└───────┴───────┴─────────┘",
        ]
    );
    assert!(lines[1]
        .spans
        .iter()
        .any(|span| span.style.has_modifier(Modifier::BOLD)));
    assert!(lines[3]
        .spans
        .iter()
        .any(|span| span.style == Theme::markdown_inline_code()));
}

#[test]
fn wraps_table_cells_to_fit_available_width() {
    let mut in_code_block = false;
    let lines = markdown_lines(
        "| Package | Description |\n| --- | --- |\n| rho | lightweight coding agent |",
        20,
        &mut in_code_block,
    );

    assert!(lines
        .iter()
        .all(|line| display_width(&line_text(line)) <= 20));
    assert_eq!(
        lines.iter().map(line_text).collect::<Vec<_>>(),
        vec![
            "┌─────────┬────────┐",
            "│ Package │ Descri │",
            "│         │ ption  │",
            "├─────────┼────────┤",
            "│ rho     │ lightw │",
            "│         │ eight  │",
            "│         │ coding │",
            "│         │  agent │",
            "└─────────┴────────┘",
        ]
    );
}

#[test]
fn table_parser_preserves_escaped_pipes_and_code_spans() {
    let mut in_code_block = false;
    let lines = markdown_lines(
        "| Expression | Result |\n| --- | --- |\n| a \\| b | `x|y` |",
        30,
        &mut in_code_block,
    );

    assert!(lines.iter().any(|line| line_text(line).contains("a | b")));
    assert!(lines.iter().any(|line| line_text(line).contains("x|y")));
}

#[test]
fn table_parser_preserves_an_escaped_trailing_pipe_without_a_border() {
    assert_eq!(
        markdown_table_cells("A | B\\|"),
        vec!["A".to_string(), "B|".to_string()]
    );
}

#[test]
fn table_parser_stops_before_lines_with_only_protected_pipes() {
    let mut in_code_block = false;
    let lines = markdown_lines(
        "| Name | Value |\n| --- | --- |\n| rho | agent |\n`a|b`",
        30,
        &mut in_code_block,
    );

    assert_eq!(
        lines.iter().map(line_text).collect::<Vec<_>>(),
        vec![
            "┌──────┬───────┐",
            "│ Name │ Value │",
            "├──────┼───────┤",
            "│ rho  │ agent │",
            "└──────┴───────┘",
            "a|b",
        ]
    );
}

#[test]
fn table_parser_preserves_pipes_in_multi_backtick_code_spans() {
    assert_eq!(
        markdown_table_cells("| Example | Result |\n"),
        vec!["Example".to_string(), "Result".to_string()]
    );
    assert_eq!(
        markdown_table_cells("| ``x|y`` | ok |"),
        vec!["``x|y``".to_string(), "ok".to_string()]
    );
    assert_eq!(
        markdown_table_cells("| `x | y |"),
        vec!["`x".to_string(), "y".to_string()]
    );
}