Pular para o conteúdo principal
O ChatCLI suporta um sistema de plugins para estender suas funcionalidades. Um plugin é um executável que segue um contrato específico, permitindo que o ChatCLI o descubra, execute e interaja com ele de forma segura. Isso permite criar comandos customizados (como @kind, @deploy) que podem orquestrar ferramentas, interagir com APIs ou realizar qualquer lógica que você possa programar.

​
Para Usuários: Gerenciando Plugins

​
Listar plugins instalados

/plugin list
Mostra todos os comandos de plugin disponíveis, incluindo plugins [builtin] (como @coder) e [remote] (de servidores conectados).

​
Instalar um plugin

Instale diretamente de um repositório Git: 
/plugin install https://github.com/usuario/meu-plugin-chatcli.git
O ChatCLI irá clonar, compilar (se for Go) e instalar o executável em ~/.chatcli/plugins/.
Segurança: A instalação de um plugin envolve baixar e executar código de terceiros. Instale plugins apenas de fontes que você confia.

​
Ver detalhes de um plugin

/plugin show <nome-do-plugin>

​
Desinstalar um plugin

/plugin uninstall <nome-do-plugin>

​
Recarregar plugins

O ChatCLI monitora automaticamente ~/.chatcli/plugins/ e recarrega quando detecta mudanças (criação, remoção, modificação). Um debounce de 500ms evita recarregamentos múltiplos. Para forçar um recarregamento manual: 
/plugin reload
Desenvolva plugins iterativamente: edite o código, recompile, envie ao diretório de plugins — o ChatCLI detectará a mudança automaticamente.

​
Para Desenvolvedores: Criando um Plugin

​
O contrato do plugin

  1. Executável — O plugin deve ser um arquivo executável (qualquer linguagem)
  2. Localização — Colocado em ~/.chatcli/plugins/
  3. Nome do comando — O nome do arquivo vira o comando. Ex: arquivo kind = comando @kind
  4. Metadados (--metadata) — Obrigatório. O executável deve responder a esta flag com JSON:
{
  "name": "@meu-comando",
  "description": "Uma breve descrição do que o plugin faz.",
  "usage": "@meu-comando <subcomando> [--flag value]",
  "version": "1.0.0"
}
  1. Schema (--schema) — Opcional. Descreve os parâmetros aceitos:
{
  "parameters": [
    {
      "name": "cluster-name",
      "type": "string",
      "required": true,
      "description": "Nome do cluster Kubernetes"
    }
  ]
}
  1. Comunicação (stdout vs stderr):
    • stdout — Apenas o resultado final (retornado ao ChatCLI/IA)
    • stderr — Logs de progresso, status e avisos (exibidos em tempo real ao usuário)

​
Exemplo: Plugin “Hello World” em Go

package main

import (
    "encoding/json"
    "flag"
    "fmt"
    "os"
    "time"
)

type Metadata struct {
    Name        string `json:"name"`
    Description string `json:"description"`
    Usage       string `json:"usage"`
    Version     string `json:"version"`
}

// logf envia mensagens de progresso para o usuário (via stderr).
func logf(format string, v ...interface{}) {
    fmt.Fprintf(os.Stderr, format, v...)
}

func main() {
    metadataFlag := flag.Bool("metadata", false, "Exibe os metadados do plugin")
    schemaFlag := flag.Bool("schema", false, "Exibe o schema de parâmetros")
    flag.Parse()

    if *metadataFlag {
        meta := Metadata{
            Name:        "@hello",
            Description: "Plugin de exemplo que demonstra o fluxo stdout/stderr.",
            Usage:       "@hello [seu-nome]",
            Version:     "1.0.0",
        }
        jsonMeta, _ := json.Marshal(meta)
        fmt.Println(string(jsonMeta))
        return
    }

    if *schemaFlag {
        schema := map[string]interface{}{
            "parameters": []map[string]interface{}{
                {
                    "name":        "nome",
                    "type":        "string",
                    "required":    false,
                    "description": "Nome da pessoa a ser cumprimentada",
                    "default":     "Mundo",
                },
            },
        }
        jsonSchema, _ := json.Marshal(schema)
        fmt.Println(string(jsonSchema))
        return
    }

    // Lógica principal
    logf("Plugin 'hello' iniciado!\n")
    time.Sleep(2 * time.Second)
    logf("   - Realizando uma tarefa demorada...\n")
    time.Sleep(2 * time.Second)

    name := "Mundo"
    if len(flag.Args()) > 0 {
        name = flag.Args()[0]
    }

    logf("Tarefa concluída!\n")

    // Resultado final vai para stdout
    fmt.Printf("Olá, %s! A hora agora é %s.", name, time.Now().Format(time.RFC1123))
}

​
Compilação e instalação

# 1. Compilar
go build -o hello ./hello/main.go

# 2. Dar permissão de execução
chmod +x hello

# 3. Criar diretório de plugins (se não existir)
mkdir -p ~/.chatcli/plugins/

# 4. Mover o executável
mv hello ~/.chatcli/plugins/

# 5. Usar no ChatCLI
/agent Olá meu nome é Fulano

​
Plugins Remotos

Ao conectar a um servidor via chatcli connect, plugins do servidor são descobertos automaticamente:
  • Aparecem em /plugin list com a tag [remote]
  • São executados no servidor (não baixados localmente por padrão)
  • Plugins locais e remotos coexistem sem conflito