beck 0.2.0

Local skills router CLI for AI agents. Your agent's skills, at its beck and call.
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

//! beck MCP server. Stdio transport, tools-only surface.
//!
//! Exposes two tools: `skills_query` and `skills_load`. No resources —
//! see TODOS.md erratum 1 for the token-math reasoning.
//!
//! Pattern adapted from mateonunez/nucleo's src/mcp/.

pub mod tools;

use rmcp::ServiceExt;
use rmcp::handler::server::ServerHandler;
use rmcp::model::{Implementation, ServerCapabilities, ServerInfo};
use rmcp::tool_handler;

use crate::consts::APP_NAME;
use crate::error::CliError;
use tools::BeckServer;

#[tool_handler]
impl ServerHandler for BeckServer {
    fn get_info(&self) -> ServerInfo {
        let mut info = ServerInfo::default();
        info.server_info = Implementation::new(APP_NAME, env!("CARGO_PKG_VERSION"));
        // CRITICAL: strict MCP clients (Claude Code, Claude Desktop) refuse to
        // register a server's tools unless it explicitly advertises the tools
        // capability in the initialize response. Leaving this at the default
        // empty capabilities silently breaks tool discovery for those clients
        // (Codex is lenient and calls tools/list anyway).
        info.capabilities = ServerCapabilities::builder().enable_tools().build();
        info.instructions = Some(
            "beck is a local skills router. Use `skills_query` to search \
             indexed SKILL.md files by free-text description, then \
             `skills_load` to fetch the full body of the chosen skill. beck \
             is populated by running `beck sync` from the shell, which walks \
             ~/.hermes/skills and ~/.claude/skills by default."
                .into(),
        );
        info
    }
}

/// Start the MCP server on stdio transport. Blocks until the client disconnects.
pub async fn start() -> std::result::Result<(), CliError> {
    let server = BeckServer::new();
    let transport = (tokio::io::stdin(), tokio::io::stdout());
    let service = server
        .serve(transport)
        .await
        .map_err(|e| CliError::Other(anyhow::anyhow!("MCP server error: {e}")))?;
    service
        .waiting()
        .await
        .map_err(|e| CliError::Other(anyhow::anyhow!("MCP server stopped: {e}")))?;
    Ok(())
}