loopflow 0.12.28

Run steps and flows with coding agents
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

//! Preserve the nested settings layout in captured Flow plans and journals.

use serde::{Deserialize, Serialize};

use super::{ConcreteSkill, RepeatPolicy, Skill};

#[derive(Debug, Serialize, Deserialize)]
pub(super) struct SavedSkill {
    skill: Skill,
    policy: Settings,
    flow_parents: Vec<String>,
}

#[derive(Debug, Serialize, Deserialize)]
struct Settings {
    #[serde(skip_serializing_if = "Option::is_none")]
    id: Option<String>,
    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
    human: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    repeat: Option<RepeatPolicy>,
}

impl From<ConcreteSkill> for SavedSkill {
    fn from(step: ConcreteSkill) -> Self {
        Self {
            skill: step.skill,
            policy: Settings {
                id: step.id,
                human: step.human,
                repeat: step.repeat,
            },
            flow_parents: step.flow_parents,
        }
    }
}

impl From<SavedSkill> for ConcreteSkill {
    fn from(step: SavedSkill) -> Self {
        Self {
            skill: step.skill,
            id: step.policy.id,
            human: step.policy.human,
            repeat: step.policy.repeat,
            flow_parents: step.flow_parents,
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::engine::ConcreteStep;

    #[test]
    fn saved_reviews_and_repeat_edges_keep_their_wire_format() {
        for settings in [
            serde_json::json!({"id": "review", "human": true}),
            serde_json::json!({"id": "decide", "repeat": {"from": "work"}}),
        ] {
            let saved = serde_json::json!({"Skill": {
                "skill": {"name": "fixture", "content": "Captured instructions"},
                "policy": settings,
                "flow_parents": ["feature"]
            }});
            let restored: ConcreteStep = serde_json::from_value(saved.clone()).unwrap();
            let ConcreteStep::Skill(step) = &restored else {
                panic!("saved skill")
            };
            assert_eq!(step.id.as_deref(), settings["id"].as_str());
            assert_eq!(step.human, settings["human"] == true);
            assert_eq!(
                step.repeat.as_ref().map(|edge| edge.from.as_str()),
                settings["repeat"]["from"].as_str()
            );
            assert_eq!(serde_json::to_value(restored).unwrap(), saved);
        }
    }
}