eggsearch 0.3.2

Lightweight MCP metasearch server for AI agents
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

//! `eggsearch providers`: report provider configuration and status.

use anyhow::Result;
use eggsearch::core::config::AppConfig;
use eggsearch::core::provider::ProviderDescriptor;
use eggsearch::mcp::ServerState;

pub fn run(cfg: &AppConfig, as_json: bool) -> Result<()> {
    let state = ServerState::build(cfg.clone())?;
    let descriptors: Vec<ProviderDescriptor> = state.adapter.provider_status();

    if as_json {
        let payload = serde_json::json!({
            "providers": descriptors,
            "mode": format!("{:?}", cfg.search.mode),
        });
        println!("{}", serde_json::to_string_pretty(&payload)?);
    } else {
        // Compute column widths dynamically for alignment
        let id_w = descriptors
            .iter()
            .map(|d| d.id.len())
            .max()
            .unwrap_or(2)
            .max(2);
        let kind_w = descriptors
            .iter()
            .map(|d| kind_str(&d.kind).len())
            .max()
            .unwrap_or(10)
            .max(10);
        let caps_w = descriptors
            .iter()
            .map(|d| d.capabilities.summary().len())
            .max()
            .unwrap_or(12)
            .max(12);

        println!(
            "{:<width_id$}  {:<8}  {:<8}  {:<width_kind$}  {:<5}  {:<12}  {:<width_caps$}",
            "ID",
            "Enabled",
            "Default",
            "Kind",
            "Key",
            "Configured",
            "Capabilities",
            width_id = id_w,
            width_kind = kind_w,
            width_caps = caps_w,
        );
        let total_width = id_w + 8 + 8 + kind_w + 5 + 12 + caps_w + 14; // separators
        println!("{}", "-".repeat(total_width));
        for d in &descriptors {
            let enabled = if d.enabled { "yes" } else { "no" };
            let default = if d.default { "yes" } else { "no" };
            let key = if d.requires_api_key { "yes" } else { "no" };
            let configured = if d.configured { "yes" } else { "no" };
            let caps = d.capabilities.summary();
            println!(
                "{:<width_id$}  {:<8}  {:<8}  {:<width_kind$}  {:<5}  {:<12}  {:<width_caps$}",
                d.id,
                enabled,
                default,
                kind_str(&d.kind),
                key,
                configured,
                caps,
                width_id = id_w,
                width_kind = kind_w,
                width_caps = caps_w,
            );
        }
    }
    Ok(())
}

fn kind_str(kind: &eggsearch::core::provider::ProviderKind) -> &'static str {
    match kind {
        eggsearch::core::provider::ProviderKind::HtmlScrape => "html_scrape",
        eggsearch::core::provider::ProviderKind::JsonApi => "json_api",
        eggsearch::core::provider::ProviderKind::ApiKey => "api_key",
    }
}