oxi-cli 0.58.0

Terminal-based AI coding assistant — multi-provider, streaming-first, extensible
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

//! `skill://` protocol handler — resolves skill names to SKILL.md content.

use std::sync::Arc;

use async_trait::async_trait;
use oxi_sdk::SdkError;
use oxi_sdk::ports::{ProtocolHandler, ResolveContext, ResolvedUrl};

/// Protocol handler for `skill://` URLs backed by the SDK's `SkillLoader` port.
pub struct SkillProtocolHandler {
    loader: Arc<dyn oxi_sdk::ports::SkillLoader>,
}

impl SkillProtocolHandler {
    /// Create a new handler backed by the given skill loader.
    pub fn new(loader: Arc<dyn oxi_sdk::ports::SkillLoader>) -> Self {
        Self { loader }
    }
}

#[async_trait]
impl ProtocolHandler for SkillProtocolHandler {
    fn scheme(&self) -> &str {
        "skill"
    }
    fn immutable(&self) -> bool {
        true
    }

    async fn resolve(
        &self,
        url: &str,
        _selector: Option<&str>,
        _ctx: &ResolveContext,
    ) -> Result<ResolvedUrl, SdkError> {
        let suffix = url.strip_prefix("skill://").unwrap_or(url);
        let parts: Vec<&str> = suffix.splitn(2, '/').collect();
        let skill_name = parts[0];
        if skill_name.is_empty() {
            return Err(SdkError::ExecutionFailed {
                reason: "skill:// URL requires a skill name".into(),
            });
        }

        let skills = self.loader.list().await?;
        let skill = skills
            .iter()
            .find(|s| s.name == skill_name)
            .ok_or_else(|| {
                let available: Vec<String> = skills.iter().map(|s| s.name.clone()).collect();
                SdkError::ExecutionFailed {
                    reason: format!(
                        "Unknown skill: '{skill_name}'. Available: {}",
                        available.join(", ")
                    ),
                }
            })?;

        let target_file = parts.get(1).copied().unwrap_or("SKILL.md");
        if target_file.starts_with('/') || target_file.contains("..") {
            return Err(SdkError::ExecutionFailed {
                reason: "Path traversal is not allowed in skill:// URLs".into(),
            });
        }

        let skill_dir = skill.path.parent().unwrap_or(std::path::Path::new(""));
        let file_path = skill_dir.join(target_file);

        let content =
            tokio::fs::read_to_string(&file_path)
                .await
                .map_err(|e| SdkError::ExecutionFailed {
                    reason: format!("Failed to read skill file '{}': {e}", file_path.display()),
                })?;

        Ok(ResolvedUrl {
            url: format!("skill://{suffix}"),
            content,
            content_type: if target_file.ends_with(".md") {
                "text/markdown".into()
            } else {
                "text/plain".into()
            },
            size: None,
            source_path: Some(file_path.to_string_lossy().into_owned()),
            notes: vec![],
            immutable: true,
        })
    }
}