selfware 0.6.2

Your personal AI workshop — software you own, software that lasts
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

use selfware::evolve::context::{ContextComposer, ContextMode};
use selfware::evolve::{Graph, Node, NodeLayer};

#[test]
fn test_context_composer_full_mode_includes_all_code() {
    let graph = Graph {
        nodes: vec![
            Node::code("agent", "src/agent"),
            Node::code("tools", "src/tools"),
        ],
        edges: vec![],
    };
    let mut composer = ContextComposer::new(graph);
    composer.set_mode(ContextMode::Full);
    assert!(composer.estimate_tokens() > 0);
    assert!(composer.included_nodes().len() == 2);
}

#[test]
fn test_modes_and_token_estimation() {
    let mut with_tokens = Node::code("agent", "src/agent");
    with_tokens.tokens = 500;
    let mut with_lines = Node::code("tools", "src/tools");
    with_lines.lines = 20;
    let graph = Graph {
        nodes: vec![with_tokens, with_lines],
        edges: vec![],
    };

    // Lite (default) includes nothing.
    let mut composer = ContextComposer::new(graph);
    assert!(composer.included_nodes().is_empty());
    assert_eq!(composer.estimate_tokens(), 0);

    // Full sums measured tokens with the lines-based fallback (20 * 10).
    composer.set_mode(ContextMode::Full);
    assert_eq!(composer.estimate_tokens(), 700);

    // Preset includes only the named entry.
    composer.set_mode(ContextMode::Preset("agent".to_string()));
    assert_eq!(composer.included_nodes(), vec!["agent".to_string()]);
    assert_eq!(composer.estimate_tokens(), 500);
}

#[test]
fn test_context_modes_and_layer_summaries_distinguish_test_nodes() {
    let mut code = Node::code("agent", "src/agent");
    code.tokens = 500;
    code.files = 3;
    code.inline_test_ranges = 2;
    code.inline_test_lines = 18;
    code.inline_test_tokens = 80;

    let mut test = Node::test("tests::agent_test", "tests/agent_test.rs");
    test.tokens = 120;
    test.files = 1;

    let mut example = Node::test("example::demo", "examples/demo.rs");
    example.tokens = 30;
    example.files = 1;

    let mut concept = Node::code("safety", "safety");
    concept.layer = NodeLayer::Concept;
    concept.path = None;
    concept.tokens = 40;
    concept.files = 0;

    let structure = Node::structure("repo::src");

    let graph = Graph {
        nodes: vec![code, test, example, concept, structure],
        edges: vec![],
    };
    let mut composer = ContextComposer::new(graph);

    assert_eq!(composer.mode_name(), "lite");
    assert!(composer.layer_summaries().is_empty());

    composer.set_mode(ContextMode::Full);
    assert_eq!(composer.mode_name(), "full");
    assert_eq!(composer.included_nodes(), vec!["agent".to_string()]);
    assert_eq!(
        composer.layer_summaries(),
        vec![selfware::evolve::ContextLayerSummary {
            layer: NodeLayer::Code,
            nodes: 1,
            tokens: 420,
            files: 3,
        }]
    );

    composer.set_mode(ContextMode::FullExtended);
    assert_eq!(composer.mode_name(), "full_extended");
    assert_eq!(
        composer.included_nodes(),
        vec![
            "agent".to_string(),
            "tests::agent_test".to_string(),
            "example::demo".to_string()
        ]
    );
    assert_eq!(composer.estimate_tokens(), 650);
    assert_eq!(composer.layer_summaries().len(), 2);
    let summary = composer.summary();
    assert_eq!(composer.mode(), &ContextMode::FullExtended);
    assert_eq!(summary.production.nodes, 1);
    assert_eq!(summary.production.tokens, 500);
    assert_eq!(summary.production.files, 3);
    assert_eq!(summary.tests.nodes, 1);
    assert_eq!(summary.tests.tokens, 120);
    assert_eq!(summary.examples.nodes, 1);
    assert_eq!(summary.examples.tokens, 30);
    assert!(!summary.file_partition_complete);
    assert_eq!(summary.production_files_with_inline_tests, 1);
    assert_eq!(summary.inline_test_ranges, 2);
    assert_eq!(summary.inline_test_lines, 18);
    assert_eq!(summary.estimated_tokens, 650);
    assert_eq!(
        serde_json::to_value(summary).unwrap()["mode"],
        "full_extended"
    );

    composer.set_mode(ContextMode::Preset("safety".to_string()));
    assert_eq!(composer.mode_name(), "preset");
    assert_eq!(composer.layer_summaries()[0].layer, NodeLayer::Concept);
}