fossil-mcp 0.1.8

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
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

//! Clone detection command.

use std::path::Path;

use crate::clones::detector::{CloneConfig, CloneDetector};
use crate::core::Language;

pub fn run(
    path: &Path,
    min_lines: usize,
    similarity: f64,
    types: &str,
    language: Option<&str>,
    format: &str,
    quiet: bool,
) -> Result<String, crate::core::Error> {
    if !quiet {
        eprintln!("Detecting clones in: {}", path.display());
    }

    // Parse and validate language filter
    let allowed_languages = if let Some(lang_str) = language {
        let (langs, invalid) = Language::parse_list(lang_str);
        if !invalid.is_empty() {
            return Err(crate::core::Error::analysis(format!(
                "Invalid language(s): {}. Valid options: {}",
                invalid.join(", "),
                Language::all()
                    .iter()
                    .map(|l| l.name())
                    .collect::<Vec<_>>()
                    .join(", ")
            )));
        }
        Some(langs)
    } else {
        None
    };

    let type_list: Vec<&str> = types.split(',').map(|t| t.trim()).collect();

    let config = CloneConfig {
        min_lines,
        min_nodes: 5,
        similarity_threshold: similarity,
        detect_type1: type_list.contains(&"type1"),
        detect_type2: type_list.contains(&"type2"),
        detect_type3: type_list.contains(&"type3"),
        detect_cross_language: true,
    };

    let detector = CloneDetector::new(config);
    let mut result = detector.detect(path)?;

    // Filter by language if specified
    if let Some(langs) = allowed_languages {
        result.groups.retain_mut(|group| {
            // Keep the clone group if at least one instance matches the language filter
            group.instances.retain(|inst| {
                if let Some(file_lang) = Language::from_file_path(&inst.file) {
                    langs.contains(&file_lang)
                } else {
                    false
                }
            });
            !group.instances.is_empty()
        });

        // Recalculate duplicate line count
        result.total_duplicated_lines = result
            .groups
            .iter()
            .flat_map(|g| g.instances.iter().map(|i| i.end_line - i.start_line + 1))
            .sum();
    }

    if !quiet {
        eprintln!(
            "Analyzed {} files: found {} clone group(s), {} duplicated lines",
            result.files_analyzed,
            result.groups.len(),
            result.total_duplicated_lines,
        );
    }

    // Format output based on format
    match format {
        "json" => {
            let output = serde_json::to_string_pretty(&result.groups)
                .map_err(|e| crate::core::Error::analysis(format!("JSON error: {e}")))?;
            Ok(output)
        }
        _ => {
            if result.groups.is_empty() {
                return Ok("No clones detected.\n".to_string());
            }

            let mut output = String::new();
            output.push_str(&format!(
                "Found {} clone group(s) ({} duplicated lines):\n\n",
                result.groups.len(),
                result.total_duplicated_lines,
            ));

            for (i, group) in result.groups.iter().enumerate() {
                output.push_str(&format!(
                    "{}. {:?} clone (similarity: {:.0}%)\n",
                    i + 1,
                    group.clone_type,
                    group.similarity * 100.0,
                ));
                for inst in &group.instances {
                    output.push_str(&format!(
                        "   {} lines {}-{}\n",
                        inst.file, inst.start_line, inst.end_line,
                    ));
                }
                output.push('\n');
            }

            Ok(output)
        }
    }
}