edgecrab-tools 0.12.1

Tool registry, ToolHandler trait, and 50+ tool implementations
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

//! Canonical skill identifier normalization (Pi / OpenClaw / Hermes aliases).

/// Normalize a raw install/search identifier into a hub-canonical form.
///
/// Handles:
/// - `git:owner/repo[@ref][/path]` / `git:https://…`
/// - `npm:package[@version]`
/// - `@owner/slug` → `clawhub:slug` (OpenClaw)
/// - `skills-sh:` ↔ `skills.sh:`
/// - path separators
pub fn normalize_identifier(raw: &str) -> String {
    let trimmed = raw.trim().replace('\\', "/");
    if trimmed.is_empty() {
        return trimmed;
    }

    // OpenClaw ClawHub owner-scoped: @owner/slug → clawhub:slug
    if let Some(rest) = trimmed.strip_prefix('@') {
        let slug = rest.rsplit('/').next().unwrap_or(rest).trim();
        if !slug.is_empty() && !slug.contains(':') {
            return format!("clawhub:{slug}");
        }
    }

    // Pi / OpenClaw git: prefix
    if let Some(rest) = trimmed.strip_prefix("git:") {
        return normalize_git_spec(rest);
    }

    // npm: kept as-is (handled by npm_pack)
    if trimmed.to_ascii_lowercase().starts_with("npm:") {
        return format!("npm:{}", trimmed[4..].trim());
    }

    // skills-sh ↔ skills.sh
    let lower = trimmed.to_ascii_lowercase();
    if let Some(rest) = lower.strip_prefix("skills-sh:") {
        let original_rest = &trimmed[trimmed.len() - rest.len()..];
        return format!("skills.sh:{original_rest}");
    }
    if let Some(rest) = lower.strip_prefix("skills-sh/") {
        let original_rest = &trimmed[trimmed.len() - rest.len()..];
        return format!("skills.sh:{original_rest}");
    }

    // well-known: keep scheme intact
    if lower.starts_with("well-known:") {
        return trimmed;
    }

    trimmed
}

fn normalize_git_spec(rest: &str) -> String {
    let rest = rest.trim();
    if rest.starts_with("http://") || rest.starts_with("https://") {
        return github_url_to_identifier(rest).unwrap_or_else(|| rest.to_string());
    }
    // git:github.com/owner/repo → owner/repo
    let rest = rest
        .strip_prefix("github.com/")
        .or_else(|| rest.strip_prefix("www.github.com/"))
        .unwrap_or(rest);
    // Drop @ref for Contents API default-branch fetch (path after @ref/…)
    let (repo_path, _ref) = split_git_ref(rest);
    repo_path.trim_matches('/').to_string()
}

fn split_git_ref(spec: &str) -> (String, Option<String>) {
    // owner/repo@main/path → (owner/repo/path, Some(main)) — keep path after ref
    if let Some(at) = spec.find('@') {
        let before = &spec[..at];
        let after = &spec[at + 1..];
        // ref may contain slashes for branches; skill path usually after last known segment.
        // Hermes/OpenClaw: git:owner/repo@ref — no extra path, or owner/repo/path without @.
        if before.matches('/').count() >= 1 {
            // If after looks like ref only (no further skill path convention), drop ref.
            // Convention: owner/repo@ref → owner/repo
            // owner/repo/path — no @
            let parts: Vec<&str> = after.splitn(2, '/').collect();
            if parts.len() == 1 {
                return (before.to_string(), Some(parts[0].to_string()));
            }
            // owner/repo@branch/with/slashes — treat entire after as ref (no path)
            return (before.to_string(), Some(after.to_string()));
        }
    }
    (spec.to_string(), None)
}

fn github_url_to_identifier(url: &str) -> Option<String> {
    let url = url.trim().trim_end_matches('/');
    let stripped = url
        .strip_prefix("https://github.com/")
        .or_else(|| url.strip_prefix("http://github.com/"))?;
    let stripped = stripped.strip_suffix(".git").unwrap_or(stripped);
    // tree/main/path or blob/main/path
    let parts: Vec<&str> = stripped.split('/').filter(|p| !p.is_empty()).collect();
    if parts.len() < 2 {
        return None;
    }
    let owner = parts[0];
    let repo = parts[1];
    if parts.len() >= 4 && (parts[2] == "tree" || parts[2] == "blob") {
        let path = parts[4..].join("/");
        if path.is_empty() {
            return Some(format!("{owner}/{repo}"));
        }
        return Some(format!("{owner}/{repo}/{path}"));
    }
    if parts.len() > 2 {
        let path = parts[2..].join("/");
        return Some(format!("{owner}/{repo}/{path}"));
    }
    Some(format!("{owner}/{repo}"))
}

// Provider filters live in `catalog.rs` (HUB_CATALOG SoT).

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn openclaw_at_owner_slug() {
        assert_eq!(normalize_identifier("@alice/my-skill"), "clawhub:my-skill");
    }

    #[test]
    fn git_owner_repo() {
        assert_eq!(
            normalize_identifier("git:owner/repo/skills/foo"),
            "owner/repo/skills/foo"
        );
    }

    #[test]
    fn git_https_url() {
        assert_eq!(
            normalize_identifier(
                "git:https://github.com/openai/skills/tree/main/skills/.curated/foo"
            ),
            "openai/skills/skills/.curated/foo"
        );
    }

    #[test]
    fn skills_sh_alias() {
        assert_eq!(normalize_identifier("skills-sh:a/b/c"), "skills.sh:a/b/c");
    }

    #[test]
    fn npm_kept() {
        assert_eq!(normalize_identifier("npm:pi-skills"), "npm:pi-skills");
    }
}