aves-corv 0.5.0

Specialized discussion domain for the Aves async application runtime
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

//! Injected catalog for materialization and lifecycle tests, without application prompt content.

use std::sync::LazyLock;

use semver::Version;

use super::library::{
    AgentDefinition, AgentId, AgentRole, AssetLibrary, SkillBundleFile, SkillDefinition, SkillId, TeamDefinition,
};

static AGENTS: LazyLock<Vec<AgentDefinition>> = LazyLock::new(|| {
    [
        ("chief-of-staff", AgentRole::Leader),
        ("equity-analyst", AgentRole::Leader),
        ("sector-analyst", AgentRole::Leader),
        ("sluice-customizer", AgentRole::Leader),
        ("equity-auditor", AgentRole::Follower),
        ("generalist-reviewer", AgentRole::Follower),
        ("sector-auditor", AgentRole::Follower),
    ]
    .into_iter()
    .map(|(id, role)| AgentDefinition {
        id: AgentId::new(id).expect("fixture id"),
        version: Version::new(1, 0, 0),
        role,
        name: "Test agent",
        job_title: "Test role",
        description: "Test asset",
        body: "Test agent instructions.\n",
    })
    .collect()
});

static SKILLS: LazyLock<Vec<SkillDefinition>> = LazyLock::new(|| {
    [
        "financial-data",
        "forensics",
        "valuation",
        "market-methodology",
        "equity-outlook",
        "flow-builder",
    ]
    .into_iter()
    .map(|id| {
        SkillDefinition::new(
            SkillId::new(id).expect("fixture id"),
            Version::new(1, 0, 0),
            "Test skill",
            "Test skill description",
            vec![
                SkillBundleFile::new("SKILL.md", "Test skill instructions.\n").expect("fixture path"),
                SkillBundleFile::new("scripts/helper.ts", "export const value = 1;\n").expect("fixture path"),
            ],
        )
        .expect("fixture skill")
    })
    .collect()
});

static TEAMS: LazyLock<Vec<TeamDefinition>> = LazyLock::new(|| {
    [
        ("chief-of-staff", &[][..], &[][..]),
        (
            "equity-analyst",
            &["equity-auditor", "generalist-reviewer"][..],
            &[
                "financial-data",
                "forensics",
                "valuation",
                "market-methodology",
                "equity-outlook",
            ][..],
        ),
        (
            "sector-analyst",
            &["sector-auditor"][..],
            &["financial-data", "valuation"][..],
        ),
        ("sluice-customizer", &[][..], &["flow-builder"][..]),
    ]
    .into_iter()
    .map(|(leader, followers, skills)| TeamDefinition {
        leader: AgentId::new(leader).expect("fixture leader"),
        followers: followers
            .iter()
            .map(|id| AgentId::new(*id).expect("fixture follower"))
            .collect(),
        skills: skills
            .iter()
            .map(|id| SkillId::new(*id).expect("fixture skill id"))
            .collect(),
        version: Version::new(1, 0, 0),
    })
    .collect()
});

pub(super) fn library() -> AssetLibrary {
    AssetLibrary::new(&AGENTS, &SKILLS, &[], &TEAMS)
}