agent-code 0.2.1

An AI-powered coding agent for the terminal, written in pure Rust
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

//! Skill tool: invoke skills dynamically from the agent.
//!
//! Unlike slash commands which are user-initiated, the SkillTool
//! lets the LLM trigger skills programmatically when it determines
//! one is appropriate for the current task.

use async_trait::async_trait;
use serde_json::json;

use super::{Tool, ToolContext, ToolResult};
use crate::error::ToolError;

pub struct SkillTool;

#[async_trait]
impl Tool for SkillTool {
    fn name(&self) -> &'static str {
        "Skill"
    }

    fn description(&self) -> &'static str {
        "Invoke a user-defined skill by name. Skills are reusable \
         workflows loaded from .rc/skills/ or ~/.config/agent-code/skills/."
    }

    fn input_schema(&self) -> serde_json::Value {
        json!({
            "type": "object",
            "required": ["skill"],
            "properties": {
                "skill": {
                    "type": "string",
                    "description": "Name of the skill to invoke"
                },
                "args": {
                    "type": "string",
                    "description": "Optional arguments passed to the skill template"
                }
            }
        })
    }

    fn is_read_only(&self) -> bool {
        true // The skill itself may invoke mutation tools, but loading is read-only.
    }

    fn is_concurrency_safe(&self) -> bool {
        false
    }

    async fn call(
        &self,
        input: serde_json::Value,
        ctx: &ToolContext,
    ) -> Result<ToolResult, ToolError> {
        let skill_name = input
            .get("skill")
            .and_then(|v| v.as_str())
            .ok_or_else(|| ToolError::InvalidInput("'skill' is required".into()))?;

        let args = input.get("args").and_then(|v| v.as_str());

        let registry = crate::skills::SkillRegistry::load_all(Some(ctx.cwd.as_path()));

        match registry.find(skill_name) {
            Some(skill) => {
                let expanded = skill.expand(args);
                Ok(ToolResult::success(format!(
                    "Skill '{}' loaded. Execute the following instructions:\n\n{}",
                    skill_name, expanded
                )))
            }
            None => {
                let available: Vec<&str> = registry.all().iter().map(|s| s.name.as_str()).collect();
                Err(ToolError::InvalidInput(format!(
                    "Skill '{}' not found. Available: {}",
                    skill_name,
                    if available.is_empty() {
                        "none".to_string()
                    } else {
                        available.join(", ")
                    }
                )))
            }
        }
    }
}