Add comprehensive MCP server search functionality

- Add 'search' subcommand to MCP CLI with multiple filter options
- Implement search_servers method in MCP service with pattern matching
- Support searching by name, URL, GitHub URL, and authentication type
- Add transport type filtering (http, stdio, websocket, any)
- Add enabled-only filtering option
- Support both human-readable and JSON output formats
- Comprehensive search across all server metadata and configuration
- Enhanced display with status icons, transport icons, and auth badges
- Integrated into existing MCP command structure with proper error handling

Co-authored-by: 0xrinegade <[email protected]>

Author: Copilot

src/clparse.rs

@@ -1048,6 +1048,36 @@ pub fn parse_command_line() -> clap::ArgMatches {
                                 .help("Automatically enable the server after setup")
                         )
                 )
+                .subcommand(
+                    Command::new("search")
+                        .about("Search for MCP servers by name, description, or features")
+                        .arg(
+                            Arg::new("query")
+                                .help("Search query (searches name, description, and features)")
+                                .required(true)
+                                .index(1)
+                        )
+                        .arg(
+                            Arg::new("transport")
+                                .long("transport")
+                                .value_name("TYPE")
+                                .value_parser(clap::builder::PossibleValuesParser::new(["http", "stdio", "any"]))
+                                .default_value("any")
+                                .help("Filter by transport type")
+                        )
+                        .arg(
+                            Arg::new("enabled_only")
+                                .long("enabled-only")
+                                .action(ArgAction::SetTrue)
+                                .help("Only show enabled servers")
+                        )
+                        .arg(
+                            Arg::new("json")
+                                .long("json")
+                                .action(ArgAction::SetTrue)
+                                .help("Output results in JSON format")
+                        )
+                )
         )
         .subcommand(
             Command::new("audit")

src/main.rs

@@ -662,6 +662,73 @@ async fn handle_mcp_command(
             }
         }
 
+        "search" => {
+            let query = mcp_sub_matches.get_one::<String>("query")
+                .expect("query is required by clap");
+            let transport = mcp_sub_matches.get_one::<String>("transport");
+            let enabled_only = mcp_sub_matches.get_flag("enabled_only");
+            let json_output = mcp_sub_matches.get_flag("json");
+            
+            let transport_filter = transport.map(|t| if t == "any" { None } else { Some(t.as_str()) }).flatten();
+            let results = mcp_service.search_servers(query, transport_filter, enabled_only);
+            
+            if results.is_empty() {
+                println!("🔍 No MCP servers found matching query: '{}'", query);
+                if enabled_only {
+                    println!("💡 Try removing the --enabled-only filter to see all servers");
+                }
+                if transport_filter.is_some() {
+                    println!("💡 Try changing the transport filter or use --transport=any");
+                }
+            } else {
+                if json_output {
+                    let json_results: Vec<serde_json::Value> = results.iter().map(|(id, config)| {
+                        serde_json::json!({
+                            "id": id,
+                            "name": config.name,
+                            "url": config.url,
+                            "transport": match config.transport_type {
+                                McpTransportType::Http => "http",
+                                McpTransportType::Websocket => "websocket",
+                                McpTransportType::Stdio => "stdio"
+                            },
+                            "enabled": config.enabled,
+                            "has_auth": config.auth.is_some(),
+                            "github_url": config.github_url
+                        })
+                    }).collect();
+                    println!("{}", serde_json::to_string_pretty(&json_results)?);
+                } else {
+                    println!("🔍 Found {} MCP server(s) matching '{}:'", results.len(), query);
+                    println!();
+                    
+                    for (id, config) in results {
+                        let status_icon = if config.enabled { "🟢" } else { "🔴" };
+                        let transport_icon = match config.transport_type {
+                            McpTransportType::Http => "🌐",
+                            McpTransportType::Websocket => "🔗", 
+                            McpTransportType::Stdio => "⚡",
+                        };
+                        let auth_badge = if config.auth.is_some() { " 🔐" } else { "" };
+                        
+                        println!("  {} {} {} {}{}", status_icon, transport_icon, id, config.name, auth_badge);
+                        println!("     URL: {}", config.url);
+                        
+                        if let Some(github_url) = &config.github_url {
+                            println!("     GitHub: {}", github_url);
+                        }
+                        
+                        if let Some(local_path) = &config.local_path {
+                            println!("     Local: {}", local_path);
+                        }
+                        
+                        println!("     Transport: {:?}", config.transport_type);
+                        println!();
+                    }
+                }
+            }
+        }
+
         _ => {
             eprintln!("Unknown MCP subcommand: {}", mcp_sub_command);
             std::process::exit(1);

src/services/mcp_service.rs

@@ -1092,6 +1092,54 @@ impl McpService {
 
         Ok(())
     }
+
+    /// Search for MCP servers by name, description, or features  
+    pub fn search_servers(
+        &self,
+        query: &str,
+        transport_filter: Option<&str>,
+        enabled_only: bool,
+    ) -> Vec<(&String, &McpServerConfig)> {
+        let query_lower = query.to_lowercase();
+        
+        self.servers
+            .iter()
+            .filter(|(_, config)| {
+                // Filter by enabled status if requested
+                if enabled_only && !config.enabled {
+                    return false;
+                }
+                
+                // Filter by transport type if specified
+                if let Some(transport) = transport_filter {
+                    if transport != "any" {
+                        let config_transport = match config.transport_type {
+                            McpTransportType::Http => "http",
+                            McpTransportType::Websocket => "websocket", 
+                            McpTransportType::Stdio => "stdio",
+                        };
+                        if config_transport != transport {
+                            return false;
+                        }
+                    }
+                }
+                
+                // Search in name, URL, and GitHub URL
+                let name_matches = config.name.to_lowercase().contains(&query_lower);
+                let url_matches = config.url.to_lowercase().contains(&query_lower);
+                let github_matches = config.github_url.as_ref()
+                    .map(|url| url.to_lowercase().contains(&query_lower))
+                    .unwrap_or(false);
+                
+                // Also search in auth type if configured
+                let auth_matches = config.auth.as_ref()
+                    .map(|auth| auth.auth_type.to_lowercase().contains(&query_lower))
+                    .unwrap_or(false);
+                
+                name_matches || url_matches || github_matches || auth_matches
+            })
+            .collect()
+    }
 }
 
 impl Default for McpService {