IA Agentiva e Sistema de Plugins

// Eventos que acionam hot reload:
// - Write:  Modificacao de arquivo existente
// - Create: Novo plugin adicionado
// - Remove: Plugin deletado
// - Rename: Plugin renomeado

> /plugin list
Plugins Instalados (12):
  @coder          - Suite de engenharia completa          [builtin]
  @read           - Leitura atômica de arquivo            [builtin]
  @search         - Busca regex em arquivos               [builtin]
  @tree           - Árvore de diretórios                  [builtin]
  @todo           - Plano de tarefas do agente            [builtin]
  @websearch      - Busca web (DuckDuckGo/SearxNG)        [builtin]
  @webfetch       - Fetch de páginas HTTP                 [builtin]
  @scheduler      - Scheduler durável de jobs             [builtin]
  @park           - Pausa o agente para retomar depois    [builtin]
  @hello          - Plugin de exemplo                    [local]
  @k8s-diagnose   - Diagnóstico de clusters K8s          [remote]
  @dockerhub      - Consulta tags do Docker Hub           [remote]

func (m *Manager) GetPlugin(name string) (Plugin, bool) {
    p, ok := m.plugins[name]
    if !ok {
        p, ok = m.plugins["@"+name]  // Fallback automático
    }
    return p, ok
}

> /plugin install https://github.com/usuário/chatcli-plugin-k8s.git

Repositório: https://github.com/usuário/chatcli-plugin-k8s.git
Confirmar instalação? (s/N): s

Clonando repositório...
Detectado projeto Go, compilando...
Plugin @k8s instalado com sucesso!

// ~/.chatcli/plugins-src/hello/main.go
package main

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

// Metadata define a estrutura para --metadata
type Metadata struct {
    Name        string `json:"name"`
    Description string `json:"description"`
    Usage       string `json:"usage"`
    Version     string `json:"version"`
}

// Schema define a estrutura para --schema
type Schema struct {
    Parameters []Parameter `json:"parameters"`
}

type Parameter struct {
    Name        string `json:"name"`
    Type        string `json:"type"`
    Required    bool   `json:"required"`
    Description string `json:"description"`
    Default     string `json:"default,omitempty"`
}

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

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

    // Responder --metadata
    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)) // stdout para o ChatCLI
        return
    }

    // Responder --schema
    if *schemaFlag {
        schema := Schema{
            Parameters: []Parameter{
                {
                    Name:        "nome",
                    Type:        "string",
                    Required:    false,
                    Description: "Nome da pessoa a ser cumprimentada",
                    Default:     "Mundo",
                },
            },
        }
        jsonSchema, _ := json.Marshal(schema)
        fmt.Println(string(jsonSchema)) // stdout para o ChatCLI
        return
    }

    // Lógica principal do plugin
    logf("Plugin 'hello' iniciado!\n") // stderr = progresso visivel

    time.Sleep(2 * time.Second) // Simula trabalho
    logf("   Realizando uma tarefa demorada...\n")
    time.Sleep(2 * time.Second)

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

    logf("Tarefa concluida!\n") // stderr = feedback de progresso

    // Resultado final para stdout (sera enviado para a IA)
    fmt.Printf("Ola, %s! A hora agora e %s.", name, time.Now().Format(time.RFC1123))
}

# Dentro do ChatCLI
> /agent @hello Edilson

# Saída no terminal (stderr):
Plugin 'hello' iniciado!
   Realizando uma tarefa demorada...
Tarefa concluida!

// chatcli-plugin-dockerhub/main.go
package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
    "strings"
    "time"
)

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

type DockerHubResponse struct {
    Results []struct {
        Name string `json:"name"`
    } `json:"results"`
}

func main() {
    if len(os.Args) > 1 && os.Args[1] == "--metadata" {
        meta := Metadata{
            Name:        "@dockerhub",
            Description: "Consulta tags disponíveis de uma imagem no Docker Hub",
            Usage:       "@dockerhub <imagem>",
            Version:     "1.0.0",
        }
        jsonMeta, _ := json.Marshal(meta)
        fmt.Println(string(jsonMeta))
        return
    }

    if len(os.Args) < 2 {
        fmt.Fprintln(os.Stderr, "Erro: Nome da imagem e obrigatório.")
        fmt.Fprintln(os.Stderr, "Uso: @dockerhub <imagem>")
        os.Exit(1)
    }

    imageName := os.Args[1]
    fmt.Fprintf(os.Stderr, "Consultando tags para '%s'...\n", imageName)

    // Chamada a API do Docker Hub
    url := fmt.Sprintf("https://hub.docker.com/v2/repositories/library/%s/tags?page_size=25", imageName)
    client := &http.Client{Timeout: 10 * time.Second}
    resp, err := client.Get(url)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Erro na requisicao: %v\n", err)
        os.Exit(1)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    var apiResponse DockerHubResponse
    if err := json.Unmarshal(body, &apiResponse); err != nil {
        fmt.Fprintf(os.Stderr, "Erro ao parsear resposta: %v\n", err)
        os.Exit(1)
    }

    // Extrair tags
    var tags []string
    for _, result := range apiResponse.Results {
        tags = append(tags, result.Name)
    }

    fmt.Fprintf(os.Stderr, "%d tags encontradas\n", len(tags))

    // Resultado final para stdout (para a IA)
    fmt.Println(strings.Join(tags, "\n"))
}

> /agent implante a ultima versão alpine do redis

// Validação de Entrada
if len(os.Args) < 2 {
    fmt.Fprintln(os.Stderr, "Erro: Argumentos insuficientes")
    os.Exit(1)
}

// Tratamento de Erros
if err != nil {
    fmt.Fprintf(os.Stderr, "Erro: %v\n", err)
    os.Exit(1) // Exit code != 0 sinaliza erro para o ChatCLI
}

// Timeouts Internos
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()

<tool_call name="@coder" args='{"cmd":"tree","args":{"dir":"."}}'/>
<tool_call name="@coder" args='{"cmd":"read","args":{"file":"cli/agent_mode.go"}}'/>
<tool_call name="@coder" args='{"cmd":"test","args":{"dir":"."}}'/>