dirge-agent 0.7.4

Minimalistic coding agent written in Rust, optimized for memory footprint and performance
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

//! /agents handler (shared by /agent list).

use crate::config::ConfigRole;
use crate::context::agent_defs::ToolPolicy;
use crate::ui::slash::{SlashCtx, c_agent, c_result};

pub(crate) async fn cmd_agents(ctx: &mut SlashCtx<'_>, _parts: &[&str]) -> anyhow::Result<()> {
    let reg = &ctx.context.agent_defs;
    if reg.is_empty() {
        ctx.renderer.write_line(
            "no agent profiles defined — add .dirge/agents/<name>.md or a config.json \"agents\" entry",
            c_agent(),
        )?;
    } else {
        let active = ctx.context.current_agent.clone();
        ctx.renderer
            .write_line(&format!("agent profiles ({}):", reg.len()), c_agent())?;
        for a in reg.iter() {
            let model = a.model.as_deref().unwrap_or("(default model)");
            let tools = match &a.tools {
                ToolPolicy::All => "all tools".to_string(),
                ToolPolicy::Allow(v) => format!("allow: {}", v.join(", ")),
                ToolPolicy::Deny(v) => format!("deny: {}", v.join(", ")),
            };
            let marker = if active.as_deref() == Some(a.name.as_str()) {
                "* "
            } else {
                "  "
            };
            ctx.renderer.write_line(
                &format!(
                    "{}{}  [{}]  {}  ·  {}",
                    marker,
                    a.name,
                    a.source.label(),
                    model,
                    tools
                ),
                c_result(),
            )?;
            if let Some(d) = &a.description {
                ctx.renderer
                    .write_line(&format!("      {}", d), c_result())?;
            }
        }
        ctx.renderer
            .write_line("usage: /agent <name>  |  /agent off", c_agent())?;

        let roles: [(&str, ConfigRole); 6] = [
            ("review", ConfigRole::Review),
            ("escalation", ConfigRole::Escalation),
            ("summarization", ConfigRole::Summarization),
            ("subagent", ConfigRole::Subagent),
            ("critic", ConfigRole::Critic),
            ("approval", ConfigRole::Approval),
        ];
        let configured: Vec<(&str, String, Option<String>)> = roles
            .iter()
            .filter_map(|(label, role)| {
                let explicit = match role {
                    ConfigRole::Review => ctx.cfg.review_provider.is_some(),
                    ConfigRole::Escalation => ctx.cfg.escalation_provider.is_some(),
                    ConfigRole::Summarization => ctx.cfg.summarization_provider.is_some(),
                    ConfigRole::Subagent => ctx.cfg.subagent_provider.is_some(),
                    ConfigRole::Critic => ctx.cfg.critic_provider.is_some(),
                    ConfigRole::Approval => ctx.cfg.approval_provider.is_some(),
                    ConfigRole::Default => true,
                };
                if !explicit {
                    return None;
                }
                ctx.cfg
                    .resolve_role(*role)
                    .map(|(alias, entry)| (*label, alias, entry.model))
            })
            .collect();

        if configured.is_empty() {
            ctx.renderer.write_line(
                "built-in roles: all on the default model (set *_provider in config.json to route a role elsewhere)",
                c_agent(),
            )?;
        } else {
            ctx.renderer
                .write_line("built-in role routing:", c_agent())?;
            for (label, alias, model) in configured {
                let model = model.as_deref().unwrap_or("(provider default)");
                ctx.renderer
                    .write_line(&format!("  {label:<14} → {alias}  ·  {model}"), c_result())?;
            }
        }
    }
    Ok(())
}