grapha 0.4.0

Blazingly fast code intelligence CLI and MCP server for Swift and Rust
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

/// Controls which optional fields appear in CLI output.
///
/// Fields can be selected via `--fields` flag (comma-separated) or configured
/// in `grapha.toml` under `[output] default_fields`.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct FieldSet {
    pub file: bool,
    pub id: bool,
    pub locator: bool,
    pub module: bool,
    pub repo: bool,
    pub span: bool,
    pub snippet: bool,
    pub visibility: bool,
    pub signature: bool,
    pub role: bool,
}

impl Default for FieldSet {
    fn default() -> Self {
        Self {
            file: true,
            id: false,
            locator: false,
            module: false,
            repo: false,
            span: false,
            snippet: false,
            visibility: false,
            signature: false,
            role: false,
        }
    }
}

impl FieldSet {
    pub fn with_id(mut self) -> Self {
        self.id = true;
        self
    }

    pub fn with_locator(mut self) -> Self {
        self.locator = true;
        self
    }

    pub fn all() -> Self {
        Self {
            file: true,
            id: true,
            locator: true,
            module: true,
            repo: true,
            span: true,
            snippet: true,
            visibility: true,
            signature: true,
            role: true,
        }
    }

    pub fn none() -> Self {
        Self {
            file: false,
            id: false,
            locator: false,
            module: false,
            repo: false,
            span: false,
            snippet: false,
            visibility: false,
            signature: false,
            role: false,
        }
    }

    pub fn parse(input: &str) -> Self {
        match input.trim() {
            "all" | "full" => Self::all(),
            "none" => Self::none(),
            s => {
                let mut fs = Self::none();
                for field in s.split(',') {
                    match field.trim() {
                        "file" => fs.file = true,
                        "id" => fs.id = true,
                        "locator" => fs.locator = true,
                        "module" => fs.module = true,
                        "repo" => fs.repo = true,
                        "span" => fs.span = true,
                        "snippet" => fs.snippet = true,
                        "visibility" => fs.visibility = true,
                        "signature" => fs.signature = true,
                        "role" => fs.role = true,
                        _ => {}
                    }
                }
                fs
            }
        }
    }

    pub fn from_config(fields: &[String]) -> Self {
        Self::parse(&fields.join(","))
    }
}