Agentic AI and Plugin System

// Events that trigger hot reload:
// - Write:  Existing file modified
// - Create: New plugin added
// - Remove: Plugin deleted
// - Rename: Plugin renamed

> /plugin list
Installed Plugins (4):
  @coder          - Complete engineering suite               [builtin]
  @hello          - Example plugin                          [local]
  @k8s-diagnose   - K8s cluster diagnostics                 [remote]
  @dockerhub      - Query Docker Hub tags                   [remote]

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

> /plugin install https://github.com/user/chatcli-plugin-k8s.git

Repository: https://github.com/user/chatcli-plugin-k8s.git
Confirm installation? (y/N): y

Cloning repository...
Go project detected, compiling...
Plugin @k8s installed successfully!

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

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

// Metadata defines the structure for --metadata
type Metadata struct {
    Name        string `json:"name"`
    Description string `json:"description"`
    Usage       string `json:"usage"`
    Version     string `json:"version"`
}

// Schema defines the structure for --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 sends progress messages to stderr (visible to the user)
func logf(format string, v ...interface{}) {
    fmt.Fprintf(os.Stderr, format, v...)
}

func main() {
    // Discovery flags
    metadataFlag := flag.Bool("metadata", false, "Displays plugin metadata")
    schemaFlag := flag.Bool("schema", false, "Displays parameter schema")
    flag.Parse()

    // Respond to --metadata
    if *metadataFlag {
        meta := Metadata{
            Name:        "@hello",
            Description: "Example plugin that demonstrates the stdout/stderr flow",
            Usage:       "@hello [your-name]",
            Version:     "1.0.0",
        }
        jsonMeta, _ := json.Marshal(meta)
        fmt.Println(string(jsonMeta)) // stdout for ChatCLI
        return
    }

    // Respond to --schema
    if *schemaFlag {
        schema := Schema{
            Parameters: []Parameter{
                {
                    Name:        "name",
                    Type:        "string",
                    Required:    false,
                    Description: "Name of the person to greet",
                    Default:     "World",
                },
            },
        }
        jsonSchema, _ := json.Marshal(schema)
        fmt.Println(string(jsonSchema)) // stdout for ChatCLI
        return
    }

    // Main plugin logic
    logf("Plugin 'hello' started!\n") // stderr = visible progress

    time.Sleep(2 * time.Second) // Simulate work
    logf("   Performing a time-consuming task...\n")
    time.Sleep(2 * time.Second)

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

    logf("Task completed!\n") // stderr = progress feedback

    // Final result to stdout (will be sent to the AI)
    fmt.Printf("Hello, %s! The current time is %s.", name, time.Now().Format(time.RFC1123))
}

# Inside ChatCLI
> /agent @hello Edilson

# Terminal output (stderr):
Plugin 'hello' started!
   Performing a time-consuming task...
Task completed!

// 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: "Queries available tags of an image on Docker Hub",
            Usage:       "@dockerhub <image>",
            Version:     "1.0.0",
        }
        jsonMeta, _ := json.Marshal(meta)
        fmt.Println(string(jsonMeta))
        return
    }

    if len(os.Args) < 2 {
        fmt.Fprintln(os.Stderr, "Error: Image name is required.")
        fmt.Fprintln(os.Stderr, "Usage: @dockerhub <image>")
        os.Exit(1)
    }

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

    // Docker Hub API call
    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, "Request error: %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, "Response parsing error: %v\n", err)
        os.Exit(1)
    }

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

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

    // Final result to stdout (for the AI)
    fmt.Println(strings.Join(tags, "\n"))
}

> /agent deploy the latest alpine version of redis

// Input Validation
if len(os.Args) < 2 {
    fmt.Fprintln(os.Stderr, "Error: Insufficient arguments")
    os.Exit(1)
}

// Error Handling
if err != nil {
    fmt.Fprintf(os.Stderr, "Error: %v\n", err)
    os.Exit(1) // Exit code != 0 signals error to ChatCLI
}

// Internal Timeouts
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":"."}}'/>