adk-cli 0.5.0

Command-line launcher for Rust Agent Development Kit (ADK-Rust) 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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use crate::cli::SkillsCommands;
use adk_skill::{SelectionPolicy, load_skill_index, select_skills};
use anyhow::{Result, anyhow};
use serde_json::json;
use std::path::PathBuf;

pub fn run(command: SkillsCommands) -> Result<()> {
    match command {
        SkillsCommands::List { path, json: as_json } => list(&path, as_json),
        SkillsCommands::Validate { path, json: as_json } => validate(&path, as_json),
        SkillsCommands::Match {
            query,
            path,
            top_k,
            min_score,
            include_tags,
            exclude_tags,
            json: as_json,
        } => match_skills(&query, &path, top_k, min_score, include_tags, exclude_tags, as_json),
    }
}

fn list(path: &str, as_json: bool) -> Result<()> {
    let root = PathBuf::from(path);
    let index = load_skill_index(&root).map_err(|e| anyhow!(e.to_string()))?;

    if as_json {
        println!(
            "{}",
            serde_json::to_string_pretty(&json!({
                "count": index.len(),
                "skills": index.summaries(),
            }))?
        );
    } else {
        println!("Found {} skill(s)", index.len());
        for skill in index.summaries() {
            println!("- {}: {} ({})", skill.name, skill.description, skill.path.display());
        }
    }

    Ok(())
}

fn validate(path: &str, as_json: bool) -> Result<()> {
    let root = PathBuf::from(path);
    match load_skill_index(&root) {
        Ok(index) => {
            if as_json {
                println!(
                    "{}",
                    serde_json::to_string_pretty(&json!({
                        "valid": true,
                        "count": index.len(),
                        "skills": index.summaries(),
                    }))?
                );
            } else {
                println!("Skills validation succeeded ({} skill(s))", index.len());
            }
            Ok(())
        }
        Err(err) => {
            if as_json {
                println!(
                    "{}",
                    serde_json::to_string_pretty(&json!({
                        "valid": false,
                        "error": err.to_string(),
                    }))?
                );
            } else {
                eprintln!("Skills validation failed: {}", err);
            }
            Err(anyhow!(err.to_string()))
        }
    }
}

fn match_skills(
    query: &str,
    path: &str,
    top_k: usize,
    min_score: f32,
    include_tags: Vec<String>,
    exclude_tags: Vec<String>,
    as_json: bool,
) -> Result<()> {
    let root = PathBuf::from(path);
    let index = load_skill_index(&root).map_err(|e| anyhow!(e.to_string()))?;
    let policy = SelectionPolicy { top_k, min_score, include_tags, exclude_tags };
    let matches = select_skills(&index, query, &policy);

    if as_json {
        println!(
            "{}",
            serde_json::to_string_pretty(&json!({
                "query": query,
                "count": matches.len(),
                "matches": matches,
            }))?
        );
    } else {
        println!("Matched {} skill(s) for query: {}", matches.len(), query);
        for item in matches {
            println!("- {} (score {:.2})", item.skill.name, item.score);
        }
    }

    Ok(())
}