atman-runtime 1.8.0

atman flow execution runtime: evaluator, tool dispatch, provider dispatch, executor, memory stores
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
114
115
116
117
118
119
120
121
122
123
124
125

use atman_runtime::help;
use atman_runtime::meta_commands::META_COMMANDS;
use atman_runtime::tool::{ToolCtx, ToolRegistry};
use atman_runtime::tools;

fn ctx_with_tools() -> ToolCtx {
    let reg = ToolRegistry::new();
    tools::register_tier_zero(&reg);
    ToolCtx {
        registry: Some(std::sync::Arc::new(reg)),
        ..Default::default()
    }
}

fn ctx_empty() -> ToolCtx {
    ToolCtx::default()
}

#[test]
fn all_topics_non_empty() {
    let ctx = ctx_with_tools();
    for topic in help::TOPICS {
        let content = help::topic_content(topic.id, &ctx)
            .unwrap_or_else(|| panic!("topic '{}' returned None", topic.id));
        assert!(!content.is_empty(), "topic '{}' is empty", topic.id);
    }
}

#[test]
fn unknown_topic_returns_none() {
    let ctx = ctx_empty();
    assert!(help::topic_content("nonexistent", &ctx).is_none());
}

#[test]
fn index_contains_version() {
    let content = help::topic_content("index", &ctx_empty()).unwrap();
    assert!(content.contains(help::version()));
}

#[test]
fn cli_topic_contains_every_meta_command() {
    let content = help::topic_content("cli", &ctx_empty()).unwrap();
    for cmd in META_COMMANDS {
        assert!(
            content.contains(&format!(":{}`", cmd.name)),
            "cli topic missing ':{}'",
            cmd.name
        );
    }
}

#[test]
fn tools_topic_contains_every_registered_tool() {
    let ctx = ctx_with_tools();
    let content = help::topic_content("tools", &ctx).unwrap();
    let registry = ctx.registry.as_ref().unwrap();
    for name in registry.names() {
        assert!(
            content.contains(&format!("`{}`", name)),
            "tools topic missing '{}'",
            name
        );
    }
}

#[test]
fn tools_topic_offline_when_no_registry() {
    let content = help::topic_content("tools", &ctx_empty()).unwrap();
    assert!(content.contains("not available"));
}

#[test]
fn config_topic_contains_key_fields() {
    let content = help::topic_content("config", &ctx_empty()).unwrap();
    for field in ["enabled", "mode", "auto_rewrite", "scope", "outside"] {
        assert!(
            content.contains(&format!("`{field}`")),
            "config topic missing field '{field}'"
        );
    }
}

#[test]
fn mcp_topic_contains_key_fields() {
    let content = help::topic_content("mcp", &ctx_empty()).unwrap();
    for field in ["transport", "command", "tier", "timeout_ms", "disabled"] {
        assert!(
            content.contains(&format!("`{field}`")),
            "mcp topic missing field '{field}'"
        );
    }
}

#[test]
fn dsl_topic_contains_key_syntax() {
    let content = help::topic_content("dsl", &ctx_empty()).unwrap();
    assert!(content.contains("flow "));
    assert!(content.contains("llm.call("));
    assert!(content.contains("fanout"));
    assert!(content.contains("contract"));
}

#[test]
fn dsl_topic_complete_flow_examples_parse() {
    let content = help::topic_content("dsl", &ctx_empty()).unwrap();
    for (index, tail) in content.split("```atman").skip(1).enumerate() {
        let Some((block, _)) = tail.split_once("```") else {
            panic!("unterminated atman block {index}")
        };
        if block.trim_start().starts_with("flow ") {
            atman_dsl::parse::parse_file(block)
                .unwrap_or_else(|error| panic!("atman block {index} does not parse: {error}"));
        }
    }
}

#[test]
fn features_topic_contains_key_features() {
    let content = help::topic_content("features", &ctx_empty()).unwrap();
    assert!(content.contains("Compaction"));
    assert!(content.contains("MCP"));
    assert!(content.contains("Hunk Review"));
    assert!(content.contains("Injection"));
}