rho-coding-agent 1.32.0

A lightweight agent harness inspired by Pi
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

//! Plugin activation state store tests.

use super::{
    parse_state_file, PluginOrigin, PluginScope, PluginStateEntry, PluginStateFile,
    PluginStateStore,
};
use tempfile::TempDir;

// Covers: missing state files mean every plugin stays enabled.
// Owner: plugin state store.
#[test]
fn missing_state_files_default_to_enabled() {
    let home = TempDir::new().unwrap();
    let project = TempDir::new().unwrap();
    std::fs::create_dir(project.path().join(".git")).unwrap();

    let store = PluginStateStore::load(project.path(), Some(home.path())).unwrap();

    assert!(store.is_enabled(PluginScope::User, "demo"));
    assert!(store.is_enabled(PluginScope::Project, "demo"));
}

// Covers: enable/disable persists outside package directories and reloads.
// Owner: plugin state store.
#[test]
fn persists_enablement_outside_package_tree() {
    let home = TempDir::new().unwrap();
    let project = TempDir::new().unwrap();
    std::fs::create_dir(project.path().join(".git")).unwrap();

    let mut store = PluginStateStore::load(project.path(), Some(home.path())).unwrap();
    store.set_enabled(PluginScope::User, "demo", false).unwrap();

    let reloaded = PluginStateStore::load(project.path(), Some(home.path())).unwrap();
    assert!(!reloaded.is_enabled(PluginScope::User, "demo"));
    assert!(reloaded.is_enabled(PluginScope::Project, "demo"));
    assert!(home.path().join("plugins.toml").is_file());
    assert!(!project.path().join(".rho/plugins.toml").exists());
}

// Covers: install metadata and link targets round-trip through plugins.toml.
// Owner: plugin state store.
#[test]
fn records_install_metadata() {
    let home = TempDir::new().unwrap();
    let project = TempDir::new().unwrap();
    std::fs::create_dir(project.path().join(".git")).unwrap();

    let mut store = PluginStateStore::load(project.path(), Some(home.path())).unwrap();
    store
        .record_install(
            PluginScope::Project,
            "linked",
            PluginOrigin::Link,
            Some("/tmp/source".into()),
        )
        .unwrap();

    let reloaded = PluginStateStore::load(project.path(), Some(home.path())).unwrap();
    let entry = reloaded.entry(PluginScope::Project, "linked").unwrap();
    assert_eq!(
        entry,
        &PluginStateEntry {
            enabled: true,
            origin: Some(PluginOrigin::Link),
            link_target: Some("/tmp/source".into()),
        }
    );
}

// Covers: unsupported state versions and invalid keys fail closed.
// Owner: plugin state parser.
#[test]
fn rejects_invalid_state_files() {
    let cases = [
        ("bad version", "version = 2\n"),
        (
            "bad plugin name",
            "version = 1\n\n[plugins.Bad_Name]\nenabled = false\n",
        ),
        ("unknown field", "version = 1\nunexpected = true\n"),
    ];
    for (name, text) in cases {
        assert!(parse_state_file(text).is_err(), "{name}");
    }

    let ok = parse_state_file(
        r#"
version = 1

[plugins.demo]
enabled = false
origin = "install"
"#,
    )
    .unwrap();
    assert_eq!(
        ok,
        PluginStateFile {
            version: 1,
            plugins: [(
                "demo".into(),
                PluginStateEntry {
                    enabled: false,
                    origin: Some(PluginOrigin::Install),
                    link_target: None,
                }
            )]
            .into_iter()
            .collect(),
        }
    );
}