codesearch 0.1.9

A fast, intelligent CLI tool with multiple search modes (regex, fuzzy, semantic), code analysis, and dead code detection for popular programming languages
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! MCP Server Module
//!
//! Provides MCP server functionality for code search operations.
//!
//! This module is organized into sub-modules for better maintainability:
//! - `schemas`: JSON Schema implementations for MCP types
//! - `params`: Parameter structures for MCP tools
//! - `tools`: Tool implementation functions

#[cfg(feature = "mcp")]
mod params;
#[cfg(feature = "mcp")]
mod schemas;
#[cfg(feature = "mcp")]
mod tools;

#[cfg(feature = "mcp")]
pub use params::*;

#[cfg(feature = "mcp")]
use rmcp::{
    ServerHandler,
    handler::server::tool::ToolRouter,
    handler::server::wrapper::{Json, Parameters},
    service::serve_server,
    tool, tool_router,
    transport::io::stdio,
};

#[cfg(feature = "mcp")]
use crate::types::{FileInfo, SearchResult};

#[cfg(feature = "mcp")]
#[derive(Debug, Clone)]
pub struct CodeSearchMcpService {
    tool_router: ToolRouter<Self>,
}

#[cfg(feature = "mcp")]
#[tool_router]
impl CodeSearchMcpService {
    pub fn new() -> Self {
        Self {
            tool_router: Self::tool_router(),
        }
    }

    /// Search for text patterns in code files with advanced options
    #[tool(
        description = "Search for text patterns in code files with advanced options like fuzzy matching, regex, and filtering"
    )]
    pub async fn search_code(
        &self,
        params: Parameters<SearchCodeParams>,
    ) -> Json<Vec<SearchResult>> {
        tools::search_code_tool(params).await
    }

    /// List all searchable files in a directory
    #[tool(
        description = "List all searchable files in a directory with optional filtering by extensions"
    )]
    pub async fn list_files(&self, params: Parameters<ListFilesParams>) -> Json<Vec<FileInfo>> {
        tools::list_files_tool(params).await
    }

    /// Analyze codebase metrics and statistics
    #[tool(
        description = "Analyze codebase metrics and statistics. Returns JSON with file counts, line counts, and code patterns"
    )]
    pub async fn analyze_codebase(
        &self,
        params: Parameters<AnalyzeCodebaseParams>,
    ) -> Json<serde_json::Value> {
        tools::analyze_codebase_tool(params).await
    }

    /// Detect code complexity issues
    #[tool(
        description = "Detect code complexity issues. Returns files with high cyclomatic or cognitive complexity"
    )]
    pub async fn detect_complexity(
        &self,
        params: Parameters<ComplexityParams>,
    ) -> Json<serde_json::Value> {
        tools::detect_complexity_tool(params).await
    }

    /// Detect duplicate code blocks
    #[tool(description = "Detect duplicate code blocks. Returns pairs of similar code sections")]
    pub async fn detect_duplicates(
        &self,
        params: Parameters<DuplicatesParams>,
    ) -> Json<serde_json::Value> {
        tools::detect_duplicates_tool(params).await
    }

    /// Detect dead code
    #[tool(description = "Detect dead code including unused functions, variables, and imports")]
    pub async fn detect_deadcode(
        &self,
        params: Parameters<DeadcodeParams>,
    ) -> Json<serde_json::Value> {
        tools::detect_deadcode_tool(params).await
    }

    /// Detect circular dependencies
    #[tool(description = "Detect circular dependencies between modules")]
    pub async fn detect_circular(
        &self,
        params: Parameters<CircularParams>,
    ) -> Json<serde_json::Value> {
        tools::detect_circular_tool(params).await
    }

    /// Find symbol: definition, references, callers (structure-aware)
    #[tool(
        description = "Find symbol definition, references, and callers. Structure-aware search for functions, classes, and identifiers"
    )]
    pub async fn find_symbol(
        &self,
        params: Parameters<FindSymbolParams>,
    ) -> Json<serde_json::Value> {
        tools::find_symbol_tool(params).await
    }

    /// Get codebase health score
    #[tool(
        description = "Get codebase health score (0-100) from dead code, duplicates, and complexity. CI-friendly"
    )]
    pub async fn get_health(&self, params: Parameters<GetHealthParams>) -> Json<serde_json::Value> {
        tools::get_health_tool(params).await
    }
}

#[cfg(feature = "mcp")]
impl ServerHandler for CodeSearchMcpService {
    fn get_tool_router(&self) -> &ToolRouter<Self> {
        &self.tool_router
    }
}

/// Start the MCP server
#[cfg(feature = "mcp")]
pub async fn start_mcp_server() -> Result<(), Box<dyn std::error::Error>> {
    let service = CodeSearchMcpService::new();
    let transport = stdio();
    serve_server(service, transport).await?;
    Ok(())
}