Plugin SDK

type Plugin interface {
    Name() string
    Version() string
    Description() string
    Initialize(ctx *PluginContext) error
    Execute(action string, params map[string]any) (any, error)
    Shutdown() error
}

type MyPlugin struct {
    pluginhost.BasePlugin
}

func (p *MyPlugin) Execute(action string, params map[string]any) (any, error) {
    switch action {
    case "validate":
        return p.doValidate(params)
    default:
        return nil, fmt.Errorf("unknown action: %s", action)
    }
}

package main

import (
    "fmt"
    "github.com/NAEOS-foundation/naeos/internal/pluginhost"
)

type MyValidator struct {
    pluginhost.BasePlugin
}

func (v *MyValidator) Initialize(ctx *pluginhost.PluginContext) error {
    ctx.Logger.Info("MyValidator initialized", nil)
    return nil
}

func (v *MyValidator) Execute(action string, params map[string]any) (any, error) {
    if action != "validate" {
        return nil, fmt.Errorf("unsupported action: %s", action)
    }
    issues := []pluginhost.Issue{
        {Severity: "warning", Message: "custom check passed"},
    }
    return issues, nil
}

func (v *MyValidator) Shutdown() error {
    return nil
}

func main() {
    plugin := &MyValidator{}
    plugin.NameVal = "my-validator"
    plugin.VersionVal = "1.0.0"
    plugin.DescriptionVal = "Custom validation rules"
    // Registration handled by the plugin host at load time
}

go build -buildmode=plugin -o my-validator.so .

//go:build wasm
// +build wasm

package main

import (
    "github.com/NAEOS-foundation/naeos/sdk"
    "github.com/NAEOS-foundation/naeos/neir"
)

//export generate
func generate(modelPtr, modelLen uint32) uint64 {
    model := sdk.ReadNEIR(modelPtr, modelLen)
    artifacts := processModel(model)
    return sdk.WriteResult(artifacts)
}

func processModel(model *neir.Model) []sdk.Artifact {
    var artifacts []sdk.Artifact
    for _, mod := range model.Modules {
        artifacts = append(artifacts, sdk.Artifact{
            Path:    mod.Path + "/generated.go",
            Content: generateCode(mod),
        })
    }
    return artifacts
}

func main() {}

tinygo build -o plugin.wasm -target=wasi -scheduler=none .

name: my-generator
version: "1.0.0"
description: Generate Rust service scaffolding
author: NAEOS Foundation
license: Apache-2.0
dependencies:
  - neir-schema@>=2.0
actions:
  - name: generate
    description: Generate Rust service code from NEIR model
    params:
      output_dir: string
      module: string
    returns: array
config:
  template_dir:
    type: string
    description: Path to custom templates directory
    required: false
  features:
    type: array
    description: Enabled feature flags
    required: false

ctx.EventBus.Subscribe(pluginhost.EventBeforeGenerate, "my-plugin",
    func(_ string, data *pluginhost.EventData) error {
        ctx.Logger.Info("Pipeline generating", map[string]any{
            "pipeline_id": data.PipelineID,
            "mod_count":   len(data.NEIRModel.Modules),
        })
        return nil
    },
)

plugins:
  - name: my-generator
    config:
      template_dir: ./templates
      output_style: compact
      features: [typescript, openapi]

func (p *MyGenerator) Initialize(ctx *pluginhost.PluginContext) error {
    tmplDir, _ := ctx.Config["template_dir"].(string)
    features, _ := ctx.Config["features"].([]any)
    return nil
}

# From the marketplace
naeos plugin install my-generator

# From a local WASM file
naeos plugin install ./path/to/plugin.wasm

# From a Go shared object
naeos plugin install ./path/to/plugin.so

# From a container registry
naeos plugin install ghcr.io/naeos-foundation/plugins/my-generator:latest

# From a URL
naeos plugin install https://example.com/plugins/my-generator.wasm

# List installed plugins
naeos plugin list

# Update a plugin
naeos plugin update my-generator

# Remove a plugin
naeos plugin remove my-generator

# Inspect plugin metadata
naeos plugin info my-generator

# Enable/disable
naeos plugin enable my-generator
naeos plugin disable my-generator

# Run plugin tests
naeos test --plugin my-generator

# Test with a specific spec
naeos test --plugin my-generator --input-file test-spec.yaml

# Verbose output
naeos test --plugin my-generator -v

func TestMyValidator(t *testing.T) {
    p := &MyValidator{}
    ctx := &pluginhost.PluginContext{
        Logger: pluginhost.NewTestLogger(t),
    }
    if err := p.Initialize(ctx); err != nil {
        t.Fatal(err)
    }
    result, err := p.Execute("validate", map[string]any{
        "spec": "project: test",
    })
    if err != nil {
        t.Fatal(err)
    }
    issues, ok := result.([]pluginhost.Issue)
    if !ok {
        t.Fatal("expected []Issue")
    }
    if len(issues) == 0 {
        t.Error("expected at least one issue")
    }
}

# Package your plugin
naeos plugin package ./my-generator --output my-generator.tar.gz

# Publish to marketplace
naeos marketplace publish my-generator.tar.gz

# Publish with metadata
naeos marketplace publish my-generator.tar.gz \
  --tag latest \
  --description "Rust code generator"

naeos run --plugin-dir ./plugins --watch

package main

import (
    "regexp"
    "github.com/NAEOS-foundation/naeos/internal/pluginhost"
    "github.com/NAEOS-foundation/naeos/neir"
)

type NamingValidator struct {
    pluginhost.BasePlugin
    pattern *regexp.Regexp
}

func (v *NamingValidator) Initialize(ctx *pluginhost.PluginContext) error {
    v.pattern = regexp.MustCompile(`^[a-z][a-z0-9-]*$`)
    return nil
}

func (v *NamingValidator) Execute(action string, params map[string]any) (any, error) {
    model, ok := params["model"].(*neir.Model)
    if !ok {
        return nil, fmt.Errorf("missing model parameter")
    }
    var issues []pluginhost.Issue
    for _, mod := range model.Modules {
        if !v.pattern.MatchString(mod.Name) {
            issues = append(issues, pluginhost.Issue{
                Severity: "error",
                Code:     "INVALID_MODULE_NAME",
                Message:  "module name must be lowercase with hyphens",
                Location: fmt.Sprintf("modules[%s]", mod.Name),
            })
        }
    }
    return issues, nil
}

func main() {}