magi-code 0.96.2

Repository-aware CLI coding agent for terminal work
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

use crate::{
    config::{LspServerConfig, LspSettings},
    lsp::DocumentVersion,
};
use std::{collections::BTreeMap, path::Path};

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct LanguageRoute {
    pub(crate) server_id: String,
    pub(crate) language_id: String,
    pub(crate) config: LspServerConfig,
}

#[derive(Debug, Default, Clone)]
pub(crate) struct DocumentVersions {
    by_path: BTreeMap<std::path::PathBuf, DocumentVersion>,
}

impl DocumentVersions {
    pub(crate) fn next_for(&mut self, path: &Path) -> DocumentVersion {
        let entry = self
            .by_path
            .entry(path.to_path_buf())
            .or_insert(DocumentVersion(0));
        entry.0 += 1;
        *entry
    }
}

pub(crate) fn default_servers() -> BTreeMap<String, LspServerConfig> {
    BTreeMap::from([
        (
            "rust-analyzer".to_string(),
            LspServerConfig {
                command: "rust-analyzer".to_string(),
                args: Vec::new(),
                enabled: true,
            },
        ),
        (
            "typescript-language-server".to_string(),
            LspServerConfig {
                command: "typescript-language-server".to_string(),
                args: vec!["--stdio".to_string()],
                enabled: true,
            },
        ),
        (
            "pyright-langserver".to_string(),
            LspServerConfig {
                command: "pyright-langserver".to_string(),
                args: vec!["--stdio".to_string()],
                enabled: true,
            },
        ),
        (
            "gopls".to_string(),
            LspServerConfig {
                command: "gopls".to_string(),
                args: Vec::new(),
                enabled: true,
            },
        ),
    ])
}

pub(crate) fn route_for_path(path: &Path, settings: &LspSettings) -> Option<LanguageRoute> {
    let language_id = language_id_for_path(path)?.to_string();
    let server_id = server_id_for_language(&language_id)?.to_string();
    let mut servers = default_servers();
    for (key, config) in &settings.servers {
        if servers.contains_key(key) {
            servers.insert(key.clone(), config.clone());
        }
    }
    let config = servers.remove(&server_id)?;
    config.enabled.then_some(LanguageRoute {
        server_id,
        language_id,
        config,
    })
}

pub(crate) fn language_id_for_path(path: &Path) -> Option<&'static str> {
    match path.extension().and_then(|extension| extension.to_str())? {
        "rs" => Some("rust"),
        "ts" | "tsx" => Some("typescript"),
        "js" | "jsx" => Some("javascript"),
        "py" => Some("python"),
        "go" => Some("go"),
        _ => None,
    }
}

fn server_id_for_language(language_id: &str) -> Option<&'static str> {
    match language_id {
        "rust" => Some("rust-analyzer"),
        "typescript" | "javascript" => Some("typescript-language-server"),
        "python" => Some("pyright-langserver"),
        "go" => Some("gopls"),
        _ => None,
    }
}