ai-agent 0.88.0

Idiomatic agent sdk inspired by the claude code source leak
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

//! LSP Client - Language Server Protocol client
//!
//! This is a stub implementation.

use serde::{Deserialize, Serialize};

/// LSP server capabilities
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ServerCapabilities {
    #[serde(rename = "textDocumentSync")]
    pub text_document_sync: Option<serde_json::Value>,
    #[serde(rename = "hoverProvider")]
    pub hover_provider: Option<bool>,
    #[serde(rename = "completionProvider")]
    pub completion_provider: Option<serde_json::Value>,
    #[serde(rename = "definitionProvider")]
    pub definition_provider: Option<bool>,
    #[serde(rename = "referencesProvider")]
    pub references_provider: Option<bool>,
    #[serde(rename = "documentFormattingProvider")]
    pub document_formatting_provider: Option<bool>,
    #[serde(rename = "documentRangeFormattingProvider")]
    pub document_range_formatting_provider: Option<bool>,
    #[serde(rename = "codeActionProvider")]
    pub code_action_provider: Option<bool>,
}

/// Initialize params for LSP server
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct InitializeParams {
    #[serde(rename = "processId")]
    pub process_id: Option<i64>,
    #[serde(rename = "rootUri")]
    pub root_uri: Option<String>,
    #[serde(rename = "rootPath")]
    pub root_path: Option<String>,
    #[serde(rename = "workspaceFolders")]
    pub workspace_folders: Option<Vec<serde_json::Value>>,
    #[serde(rename = "initializationOptions")]
    pub initialization_options: Option<serde_json::Value>,
}

/// Initialize result from LSP server
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct InitializeResult {
    pub capabilities: ServerCapabilities,
    #[serde(rename = "serverInfo")]
    pub server_info: Option<ServerInfo>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ServerInfo {
    pub name: String,
    pub version: Option<String>,
}

/// Options for starting LSP server
#[derive(Debug, Clone, Default)]
pub struct LspStartOptions {
    pub env: Option<std::collections::HashMap<String, String>>,
    pub cwd: Option<String>,
}

/// LSP client - simple implementation
pub struct LspClientImpl {
    initialized: bool,
    capabilities: Option<ServerCapabilities>,
}

impl LspClientImpl {
    pub fn new() -> Self {
        Self {
            initialized: false,
            capabilities: None,
        }
    }

    pub fn capabilities(&self) -> Option<&ServerCapabilities> {
        self.capabilities.as_ref()
    }

    pub fn is_initialized(&self) -> bool {
        self.initialized
    }

    pub async fn start(
        &mut self,
        _command: &str,
        _args: &[String],
        _options: Option<LspStartOptions>,
    ) -> Result<(), String> {
        Ok(())
    }

    pub async fn initialize(
        &mut self,
        _params: InitializeParams,
    ) -> Result<InitializeResult, String> {
        self.initialized = true;
        Ok(InitializeResult::default())
    }

    pub async fn stop(&mut self) -> Result<(), String> {
        self.initialized = false;
        Ok(())
    }
}

impl Default for LspClientImpl {
    fn default() -> Self {
        Self::new()
    }
}

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

    #[test]
    fn test_server_capabilities_default() {
        let caps = ServerCapabilities::default();
        assert!(caps.hover_provider.is_none());
    }

    #[test]
    fn test_initialize_params_default() {
        let params = InitializeParams::default();
        assert!(params.process_id.is_none());
    }
}