coderlib 0.1.0

A Rust library for AI-powered code assistance and agentic system
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
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

//! MCP transport abstraction layer

#[cfg(feature = "mcp")]
use rmcp::transport::{TokioChildProcess, SseClientTransport};
use std::collections::HashMap;
use tokio::process::Command;

use crate::mcp::{
    config::McpTransportConfig,
    error::{McpError, McpResult},
};

/// Transport abstraction for MCP connections
pub enum McpTransport {
    /// Standard I/O transport
    #[cfg(feature = "mcp")]
    Stdio(TokioChildProcess),
    /// Server-Sent Events transport
    #[cfg(feature = "mcp")]
    Sse(SseClientTransport<reqwest::Client>),
    /// Placeholder when MCP feature is disabled
    #[cfg(not(feature = "mcp"))]
    Disabled,
}

impl McpTransport {
    /// Create a new transport from configuration
    pub async fn from_config(
        config: &McpTransportConfig,
        env_vars: HashMap<String, String>,
        working_dir: Option<&std::path::Path>,
    ) -> McpResult<Self> {
        match config {
            McpTransportConfig::Stdio { command, args } => {
                Self::create_stdio_transport(command, args, env_vars, working_dir).await
            }
            McpTransportConfig::Sse { url, headers } => {
                Self::create_sse_transport(url, headers).await
            }
        }
    }
    
    /// Create a stdio transport
    #[cfg(feature = "mcp")]
    async fn create_stdio_transport(
        command: &str,
        args: &[String],
        env_vars: HashMap<String, String>,
        working_dir: Option<&std::path::Path>,
    ) -> McpResult<Self> {
        let mut cmd = Command::new(command);
        
        // Add arguments
        for arg in args {
            cmd.arg(arg);
        }
        
        // Set working directory
        if let Some(dir) = working_dir {
            cmd.current_dir(dir);
        }
        
        // Set environment variables
        for (key, value) in env_vars {
            cmd.env(key, value);
        }
        
        let transport = TokioChildProcess::new(cmd)
            .map_err(|e| McpError::transport(format!("Failed to create child process: {}", e)))?;
        
        Ok(McpTransport::Stdio(transport))
    }
    
    #[cfg(not(feature = "mcp"))]
    async fn create_stdio_transport(
        _command: &str,
        _args: &[String],
        _env_vars: HashMap<String, String>,
        _working_dir: Option<&std::path::Path>,
    ) -> McpResult<Self> {
        Err(McpError::configuration("MCP feature not enabled"))
    }
    
    /// Create an SSE transport
    #[cfg(feature = "mcp")]
    async fn create_sse_transport(
        url: &str,
        headers: &HashMap<String, String>,
    ) -> McpResult<Self> {
        let transport = SseClientTransport::start(url).await
            .map_err(|e| McpError::transport(format!("Failed to create SSE transport: {}", e)))?;

        // TODO: Add header support for SSE transport
        // Headers are currently not supported in the simple start() method

        Ok(McpTransport::Sse(transport))
    }
    
    #[cfg(not(feature = "mcp"))]
    async fn create_sse_transport(
        _url: &str,
        _headers: &HashMap<String, String>,
    ) -> McpResult<Self> {
        Err(McpError::configuration("MCP feature not enabled"))
    }
    
    /// Get a description of the transport
    pub fn description(&self) -> String {
        match self {
            #[cfg(feature = "mcp")]
            McpTransport::Stdio(_) => "stdio".to_string(),
            #[cfg(feature = "mcp")]
            McpTransport::Sse(_) => "sse".to_string(),
            #[cfg(not(feature = "mcp"))]
            McpTransport::Disabled => "disabled".to_string(),
        }
    }
    
    /// Check if the transport is stdio
    pub fn is_stdio(&self) -> bool {
        matches!(self, McpTransport::Stdio(_))
    }
    
    /// Check if the transport is SSE
    pub fn is_sse(&self) -> bool {
        matches!(self, McpTransport::Sse(_))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::mcp::config::McpTransportConfig;
    
    #[test]
    fn test_transport_description() {
        #[cfg(not(feature = "mcp"))]
        {
            let transport = McpTransport::Disabled;
            assert_eq!(transport.description(), "disabled");
        }
    }
    
    #[test]
    fn test_transport_type_checks() {
        #[cfg(not(feature = "mcp"))]
        {
            let transport = McpTransport::Disabled;
            assert!(!transport.is_stdio());
            assert!(!transport.is_sse());
        }
    }
}