rtango 0.4.0

Package manager for AI agent skills, agents, and system instruction files
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

use std::path::Path;

use anyhow::bail;

use crate::agent::{self, SourceKind};
use crate::engine::{compute_plan, managed_gitignore_entries};
use crate::error::RtangoError;
use crate::spec::io::{gitignore_update, lock_path, rtango_dir, spec_path, write_gitignore};
use crate::spec::{AgentName, Defaults, Lock, Rule, RuleKind, Source, Spec};

pub fn exec(
    root: &Path,
    force: bool,
    no_detect: bool,
    gitignore_targets: bool,
) -> anyhow::Result<()> {
    let spec_path = spec_path(root);
    let lock_path = lock_path(root);

    if spec_path.exists() && !force {
        bail!(RtangoError::SpecExists);
    }

    let detected = if no_detect {
        Vec::new()
    } else {
        let detected = agent::detect_agents(root);
        if detected.is_empty() {
            bail!(RtangoError::NoAgentsDetected);
        }
        detected
    };

    let agent_names: Vec<AgentName> = detected.iter().map(|d| d.name.clone()).collect();

    let mut rules = Vec::new();
    for agent in &detected {
        for source in &agent.sources {
            rules.push(Rule {
                id: source.id.clone(),
                source: Source::Local(source.path.clone()),
                schema_agent: agent.name.clone(),
                on_target_modified: None,
                kind: match source.kind {
                    SourceKind::SkillSet => RuleKind::skill_set(),
                    SourceKind::AgentSet => RuleKind::agent_set(),
                },
            });
        }
    }

    let spec = Spec {
        version: 1,
        agents: agent_names.clone(),
        defaults: Defaults {
            gitignore_targets,
            ..Defaults::default()
        },
        rules,
    };

    let lock = Lock {
        version: 1,
        tracked_agents: agent_names,
        owners: vec![],
        deployments: vec![],
    };

    let spec_yaml = serde_yml::to_string(&spec)?;
    let lock_yaml = serde_yml::to_string(&lock)?;

    std::fs::create_dir_all(rtango_dir(root))?;
    std::fs::write(&spec_path, &spec_yaml)?;
    std::fs::write(&lock_path, &lock_yaml)?;

    if gitignore_targets {
        let plan = compute_plan(root, &spec, &lock, true, true)?;
        let update = gitignore_update(root, &managed_gitignore_entries(&plan, None))?;
        if update.changed {
            write_gitignore(root, &update.content)?;
        }
    }

    Ok(())
}