fossil-mcp 0.1.2

Multi-language static analysis toolkit with MCP server. Detects dead code, code clones, and AI scaffolding.
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

//! AST visitor and transformer traits.

use super::node::ASTNode;

/// Visitor pattern for read-only AST traversal.
pub trait ASTVisitor {
    fn visit_node(&mut self, node: &ASTNode) {
        self.walk(node);
    }

    fn walk(&mut self, node: &ASTNode) {
        for child in node.children() {
            self.visit_node(child);
        }
    }
}

/// Transformer pattern for AST rewriting.
pub trait ASTTransformer {
    fn transform_node(&mut self, node: ASTNode) -> ASTNode {
        self.walk_transform(node)
    }

    fn walk_transform(&mut self, node: ASTNode) -> ASTNode {
        match node {
            ASTNode::Function {
                name,
                params,
                return_type,
                body,
                span,
                visibility,
                is_async,
                is_method,
                generic_params,
                attributes,
            } => ASTNode::Function {
                name,
                params,
                return_type,
                body: body.map(|b| b.into_iter().map(|n| self.transform_node(n)).collect()),
                span,
                visibility,
                is_async,
                is_method,
                generic_params,
                attributes,
            },
            ASTNode::Module {
                name,
                items,
                span,
                visibility,
            } => ASTNode::Module {
                name,
                items: items.into_iter().map(|n| self.transform_node(n)).collect(),
                span,
                visibility,
            },
            ASTNode::Trait {
                name,
                methods,
                span,
                visibility,
                generic_params,
            } => ASTNode::Trait {
                name,
                methods: methods
                    .into_iter()
                    .map(|n| self.transform_node(n))
                    .collect(),
                span,
                visibility,
                generic_params,
            },
            ASTNode::ImplBlock {
                type_name,
                trait_name,
                methods,
                span,
                generic_params,
            } => ASTNode::ImplBlock {
                type_name,
                trait_name,
                methods: methods
                    .into_iter()
                    .map(|n| self.transform_node(n))
                    .collect(),
                span,
                generic_params,
            },
            other => other,
        }
    }
}