vv-agent 0.1.3

VectorVein agent runtime, SDK, CLI, tools, and workspace backends
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
112
113
114
115
116
117
118
119
120
121
122

use std::path::{Path, PathBuf};

use serde_json::Value;

use super::errors::SkillError;
use super::models::SkillEntry;
use super::normalize::normalize_skill_list;
use super::parser::{find_skill_md, read_properties};

pub const MAX_SKILLS_PROMPT_CHARS: usize = 8000;

pub fn skill_entry_to_xml(entry: &SkillEntry, include_location: bool) -> String {
    let mut lines = vec![
        "<skill>".to_string(),
        "<name>".to_string(),
        escape_xml(&entry.name),
        "</name>".to_string(),
        "<description>".to_string(),
        escape_xml(&entry.description),
        "</description>".to_string(),
    ];
    if include_location {
        if let Some(location) = &entry.location {
            lines.extend([
                "<location>".to_string(),
                escape_xml(location),
                "</location>".to_string(),
            ]);
        }
    }
    lines.push("</skill>".to_string());
    lines.join("\n")
}

pub fn render_skills_xml(entries: &[SkillEntry], budget: usize) -> String {
    if entries.is_empty() {
        return "<available_skills>\n</available_skills>".to_string();
    }

    let full = render_all(entries, true);
    if full.len() <= budget {
        return full;
    }

    let compact = render_all(entries, false);
    if compact.len() <= budget {
        return compact;
    }

    let wrapper_overhead = "<available_skills>\n</available_skills>".len() + 80;
    let mut remaining = budget.saturating_sub(wrapper_overhead);
    let mut lines = vec!["<available_skills>".to_string()];
    let mut included = 0usize;
    for entry in entries {
        let xml = skill_entry_to_xml(entry, false);
        if xml.len() + 1 > remaining {
            break;
        }
        remaining = remaining.saturating_sub(xml.len() + 1);
        lines.push(xml);
        included += 1;
    }
    let omitted = entries.len().saturating_sub(included);
    if omitted > 0 {
        lines.push(format!(
            "<!-- {omitted} more skills available; use activate_skill to discover -->"
        ));
    }
    lines.push("</available_skills>".to_string());
    lines.join("\n")
}

pub fn to_available_skills_xml(skill_dirs: &[PathBuf]) -> Result<String, SkillError> {
    if skill_dirs.is_empty() {
        return Ok("<available_skills>\n</available_skills>".to_string());
    }

    let mut lines = vec!["<available_skills>".to_string()];
    for skill_dir in skill_dirs {
        let normalized_dir = skill_dir
            .canonicalize()
            .unwrap_or_else(|_| skill_dir.clone());
        let properties = read_properties(&normalized_dir)?;
        let skill_md = find_skill_md(&normalized_dir);
        let entry = SkillEntry {
            name: properties.name,
            description: properties.description,
            location: skill_md.map(|path| path.to_string_lossy().replace('\\', "/")),
            allowed_tools: properties.allowed_tools,
            metadata: properties.metadata,
            ..SkillEntry::default()
        };
        lines.push(skill_entry_to_xml(&entry, true));
    }
    lines.push("</available_skills>".to_string());
    Ok(lines.join("\n"))
}

pub fn metadata_to_prompt_entries(
    available_skills: Option<&Value>,
    workspace: Option<&Path>,
) -> Vec<SkillEntry> {
    normalize_skill_list(available_skills, workspace, false)
}

fn render_all(entries: &[SkillEntry], include_location: bool) -> String {
    let mut lines = vec!["<available_skills>".to_string()];
    for entry in entries {
        lines.push(skill_entry_to_xml(entry, include_location));
    }
    lines.push("</available_skills>".to_string());
    lines.join("\n")
}

fn escape_xml(value: &str) -> String {
    value
        .replace('&', "&amp;")
        .replace('<', "&lt;")
        .replace('>', "&gt;")
        .replace('"', "&quot;")
        .replace('\'', "&#x27;")
}