Expondo uma CLI como uma ferramenta MCP na biblioteca padrão Go

commitbrief mcp transforma o pipeline de revisão em um servidor de Protocolo de Contexto de Modelo, para que um agente possa executar uma revisão de código como uma chamada de ferramenta — tipicamente uma auto-verificação antes de submeter o código que acabou de escrever. Adicionar suporte a MCP geralmente significa integrar um SDK. O servidor do CommitBrief é encoding/json mais bufio, dois arquivos e zero novas dependências — porque a superfície que um servidor MCP stdio realmente precisa é pequena o suficiente que implementá-lo manualmente custa menos do que a dependência.

Resumo

• commitbrief mcp fala JSON-RPC 2.0 sobre stdio delimitado por linha. A revisão do protocolo anunciada é 2024-11-05.
• O servidor é apenas da biblioteca padrão: encoding/json para os envelopes, bufio para a estrutura. Sem SDK MCP, sem nova dependência para auditoria de licença.
• Ele expõe uma ferramenta, review, que executa o exato mesmo pipeline que commitbrief --json e retorna descobertas do schema-v1 mais um resumo em texto curto.
• O limite. É apenas o transporte stdio, a revisão ainda custa uma chamada real ao provedor, e é o mesmo zeroth reviewer — agora invocável por agente, não mais inteligente.

O transporte é uma linha e um flush

A decisão de estruturação inteira está no documento do pacote, e é uma decisão não de fazer algo:

// O transporte é JSON delimitado por linha: cada mensagem JSON-RPC é um único
// objeto escrito em sua própria linha e enviado [...] Nós intencionalmente não
// implementamos a estrutura opcional do cabeçalho Content-Length — a forma de linha é
// mais simples, é o que os hosts de referência default usam sobre stdio, e mantém o
// leitor como um bufio.Scanner simples.

Então o loop de leitura é um bufio.Scanner, uma mensagem por linha, com o limite de token elevado porque um documento de descobertas pode ultrapassar o padrão de 64 KiB:

func (s *Server) Serve(ctx context.Context, r io.Reader, w io.Writer) error {
    scanner := bufio.NewScanner(r)
    scanner.Buffer(make([]byte, 0, 64*1024), maxMessageBytes)
    writer := bufio.NewWriter(w)

    for scanner.Scan() {
        line := scanner.Bytes()
        if len(line) == 0 {
            continue // tolerar linhas separadoras em branco entre mensagens
        }
        resp, emit := s.dispatch(ctx, line)
        if !emit {
            continue // notificação: sem resposta na rede
        }
        if err := writeMessage(writer, resp); err != nil {
            return err
        }
    }
    // ...
}

maxMessageBytes é 16 MiB — suficiente para a maior revisão realista, limitado para que um parente descontrolado não possa esgotar a memória. Cada resposta é escrita e enviada imediatamente, porque stdio é interativo e um buffer não enviado poderia travar o handshake.

Os métodos que importam

MCP sobre stdio precisa de um punhado de métodos, e o despachante é um switch:

switch req.Method {
case "initialize":
    return s.handleInitialize(req)
case "tools/list":
    return s.handleListTools(req)
case "tools/call":
    return s.handleCallTool(ctx, req)
case "ping":
    resp, _ := newResult(req.ID, struct{}{})
    return resp, !req.isNotification()
default:
    // "notifications/initialized" e qualquer outra notificação: reconhecimento por silêncio.
    if req.isNotification() {
        // não faz nada
    }
}