atman-runtime 1.2.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
126
127

use atman_runtime::tool::{ToolArgs, ToolCtx};
use atman_runtime::tools::register_tier_zero;
use atman_runtime::value::Value;
use std::sync::{Arc, Mutex};
use tempfile::TempDir;

#[tokio::test]
async fn fs_edit_end_to_end_read_then_edit_flow() {
    let dir = TempDir::new().unwrap();
    let path = dir.path().join("script.py");
    tokio::fs::write(
        &path,
        b"def greet():\n    print(\"hi\")\n\ndef main():\n    greet()\n",
    )
    .await
    .unwrap();

    let mut registry = atman_runtime::tool::ToolRegistry::new();
    register_tier_zero(&mut registry);

    let tracker = Arc::new(Mutex::new(std::collections::HashSet::new()));
    let ctx = ToolCtx::new().with_read_files(tracker.clone());

    let read_tool = registry.get("fs.read").expect("fs.read registered");
    let edit_tool = registry.get("fs.edit").expect("fs.edit registered");

    let edit_before_read = edit_tool
        .call(
            ToolArgs {
                positional: vec![],
                named: vec![
                    ("path".into(), Value::Path(path.clone())),
                    ("old_string".into(), Value::Str("print(\"hi\")".into())),
                    ("new_string".into(), Value::Str("print(\"hello\")".into())),
                ],
            },
            &ctx,
        )
        .await;
    assert!(
        matches!(&edit_before_read, Err(e) if format!("{e}").contains("has not been read")),
        "expected read-before-edit gate, got {edit_before_read:?}"
    );

    read_tool
        .call(
            ToolArgs {
                positional: vec![Value::Path(path.clone())],
                named: vec![],
            },
            &ctx,
        )
        .await
        .expect("fs.read succeeds");

    let edit_result = edit_tool
        .call(
            ToolArgs {
                positional: vec![],
                named: vec![
                    ("path".into(), Value::Path(path.clone())),
                    ("old_string".into(), Value::Str("print(\"hi\")".into())),
                    (
                        "new_string".into(),
                        Value::Str("print(\"hello, world\")".into()),
                    ),
                ],
            },
            &ctx,
        )
        .await
        .expect("edit after read succeeds");
    assert!(matches!(edit_result, Value::Struct(_)));

    let after = tokio::fs::read_to_string(&path).await.unwrap();
    assert!(after.contains("print(\"hello, world\")"));
    assert!(!after.contains("print(\"hi\")"));
    assert!(after.contains("def greet"));
    assert!(after.contains("def main"));
}

#[tokio::test]
async fn fs_edit_ambiguous_match_returns_actionable_error_through_registry() {
    let dir = TempDir::new().unwrap();
    let path = dir.path().join("todos.txt");
    tokio::fs::write(&path, b"TODO first\nnormal\nTODO second\n")
        .await
        .unwrap();

    let mut registry = atman_runtime::tool::ToolRegistry::new();
    register_tier_zero(&mut registry);

    let tracker = Arc::new(Mutex::new(std::collections::HashSet::new()));
    let ctx = ToolCtx::new().with_read_files(tracker);
    registry
        .get("fs.read")
        .unwrap()
        .call(
            ToolArgs {
                positional: vec![Value::Path(path.clone())],
                named: vec![],
            },
            &ctx,
        )
        .await
        .unwrap();

    let err = registry
        .get("fs.edit")
        .unwrap()
        .call(
            ToolArgs {
                positional: vec![],
                named: vec![
                    ("path".into(), Value::Path(path)),
                    ("old_string".into(), Value::Str("TODO".into())),
                    ("new_string".into(), Value::Str("DONE".into())),
                ],
            },
            &ctx,
        )
        .await
        .unwrap_err();
    let msg = format!("{err}");
    assert!(msg.contains("matches 2 times"), "msg: {msg}");
    assert!(msg.contains("replace_all=true"));
}