feat(agent): plugin bootstrap wiring + diagnostics (2/4)

cmd/picoclaw/internal/agent/helpers.go

@@ -12,6 +12,7 @@ import (
 	"github.com/chzyer/readline"
 
 	"github.com/sipeed/picoclaw/cmd/picoclaw/internal"
+	"github.com/sipeed/picoclaw/cmd/picoclaw/internal/pluginruntime"
 	"github.com/sipeed/picoclaw/pkg/agent"
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/logger"
@@ -51,6 +52,24 @@ func agentCmd(message, sessionKey, model string, debug bool) error {
 	defer msgBus.Close()
 	agentLoop := agent.NewAgentLoop(cfg, msgBus, provider)
 
+	pluginsToEnable, pluginSummary, err := pluginruntime.ResolveConfiguredPlugins(cfg)
+	if err != nil {
+		return fmt.Errorf("error resolving configured plugins: %w", err)
+	}
+	if len(pluginsToEnable) > 0 {
+		if err := agentLoop.EnablePlugins(pluginsToEnable...); err != nil {
+			return fmt.Errorf("error enabling plugins: %w", err)
+		}
+	}
+	logger.InfoCF("agent", "Plugin selection resolved",
+		map[string]any{
+			"plugins_enabled":          pluginSummary.Enabled,
+			"plugins_disabled":         pluginSummary.Disabled,
+			"plugins_unknown_enabled":  pluginSummary.UnknownEnabled,
+			"plugins_unknown_disabled": pluginSummary.UnknownDisabled,
+			"plugins_warnings":         pluginSummary.Warnings,
+		})
+
 	// Print agent startup info (only for interactive mode)
 	startupInfo := agentLoop.GetStartupInfo()
 	logger.InfoCF("agent", "Agent initialized",

cmd/picoclaw/internal/gateway/helpers.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/sipeed/picoclaw/cmd/picoclaw/internal"
+	"github.com/sipeed/picoclaw/cmd/picoclaw/internal/pluginruntime"
 	"github.com/sipeed/picoclaw/pkg/agent"
 	"github.com/sipeed/picoclaw/pkg/bus"
 	"github.com/sipeed/picoclaw/pkg/channels"
@@ -61,6 +62,23 @@ func gatewayCmd(debug bool) error {
 
 	msgBus := bus.NewMessageBus()
 	agentLoop := agent.NewAgentLoop(cfg, msgBus, provider)
+	pluginsToEnable, pluginSummary, err := pluginruntime.ResolveConfiguredPlugins(cfg)
+	if err != nil {
+		return fmt.Errorf("error resolving configured plugins: %w", err)
+	}
+	if len(pluginsToEnable) > 0 {
+		if enableErr := agentLoop.EnablePlugins(pluginsToEnable...); enableErr != nil {
+			return fmt.Errorf("error enabling plugins: %w", enableErr)
+		}
+	}
+	logger.InfoCF("agent", "Plugin selection resolved",
+		map[string]any{
+			"plugins_enabled":          pluginSummary.Enabled,
+			"plugins_disabled":         pluginSummary.Disabled,
+			"plugins_unknown_enabled":  pluginSummary.UnknownEnabled,
+			"plugins_unknown_disabled": pluginSummary.UnknownDisabled,
+			"plugins_warnings":         pluginSummary.Warnings,
+		})
 
 	// Print agent startup info
 	fmt.Println("\n📦 Agent Status:")

cmd/picoclaw/internal/pluginruntime/bootstrap.go

@@ -0,0 +1,64 @@
+package pluginruntime
+
+import (
+	"fmt"
+
+	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/plugin"
+	"github.com/sipeed/picoclaw/pkg/plugin/builtin"
+)
+
+type Summary struct {
+	Enabled         []string
+	Disabled        []string
+	UnknownEnabled  []string
+	UnknownDisabled []string
+	Warnings        []string
+}
+
+func ResolveConfiguredPlugins(cfg *config.Config) ([]plugin.Plugin, Summary, error) {
+	if cfg == nil {
+		return nil, Summary{}, fmt.Errorf("config is nil")
+	}
+
+	resolved, err := plugin.ResolveSelection(
+		builtin.Names(),
+		plugin.SelectionInput{
+			DefaultEnabled: cfg.Plugins.DefaultEnabled,
+			Enabled:        cfg.Plugins.Enabled,
+			Disabled:       cfg.Plugins.Disabled,
+		},
+	)
+
+	summary := Summary{
+		Enabled:         resolved.EnabledNames,
+		Disabled:        resolved.DisabledNames,
+		UnknownEnabled:  resolved.UnknownEnabled,
+		UnknownDisabled: resolved.UnknownDisabled,
+		Warnings:        resolved.Warnings,
+	}
+	if err != nil {
+		return nil, summary, err
+	}
+
+	catalog := builtin.Catalog()
+	normalizedCatalog := make(map[string]builtin.Factory, len(catalog))
+	for name, factory := range catalog {
+		normalizedCatalog[plugin.NormalizePluginName(name)] = factory
+	}
+
+	instances := make([]plugin.Plugin, 0, len(resolved.EnabledNames))
+	for _, name := range resolved.EnabledNames {
+		factory, ok := normalizedCatalog[name]
+		if !ok {
+			return nil, summary, fmt.Errorf("builtin plugin %q has no factory", name)
+		}
+		instance := factory()
+		if instance == nil {
+			return nil, summary, fmt.Errorf("builtin plugin %q factory returned nil", name)
+		}
+		instances = append(instances, instance)
+	}
+
+	return instances, summary, nil
+}

cmd/picoclaw/internal/pluginruntime/bootstrap_test.go

@@ -0,0 +1,106 @@
+package pluginruntime
+
+import (
+	"slices"
+	"strings"
+	"testing"
+
+	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/plugin"
+	"github.com/sipeed/picoclaw/pkg/plugin/builtin"
+)
+
+func TestResolveConfiguredPlugins_UnknownEnabledReturnsError(t *testing.T) {
+	cfg := config.DefaultConfig()
+	cfg.Plugins = config.PluginsConfig{
+		DefaultEnabled: false,
+		Enabled:        []string{"missing-plugin"},
+		Disabled:       []string{},
+	}
+
+	instances, summary, err := ResolveConfiguredPlugins(cfg)
+	if err == nil {
+		t.Fatal("expected error for unknown enabled plugin")
+	}
+	if !strings.Contains(err.Error(), "missing-plugin") {
+		t.Fatalf("expected error to mention missing plugin, got %v", err)
+	}
+	if len(instances) != 0 {
+		t.Fatalf("expected no instances on error, got %d", len(instances))
+	}
+	if !slices.Equal(summary.UnknownEnabled, []string{"missing-plugin"}) {
+		t.Fatalf("UnknownEnabled mismatch: got %v", summary.UnknownEnabled)
+	}
+}
+
+func TestResolveConfiguredPlugins_ReturnsDeterministicInstances(t *testing.T) {
+	available := builtin.Names()
+	if len(available) == 0 {
+		t.Fatal("expected at least one builtin plugin")
+	}
+
+	enabled := slices.Clone(available)
+	slices.Reverse(enabled)
+
+	cfg := config.DefaultConfig()
+	cfg.Plugins = config.PluginsConfig{
+		DefaultEnabled: false,
+		Enabled:        enabled,
+		Disabled:       []string{},
+	}
+
+	instances, summary, err := ResolveConfiguredPlugins(cfg)
+	if err != nil {
+		t.Fatalf("ResolveConfiguredPlugins() error = %v", err)
+	}
+
+	gotNames := pluginNames(instances)
+	if !slices.Equal(gotNames, available) {
+		t.Fatalf("plugin names mismatch: got %v, want %v", gotNames, available)
+	}
+	if !slices.Equal(summary.Enabled, available) {
+		t.Fatalf("summary enabled mismatch: got %v, want %v", summary.Enabled, available)
+	}
+}
+
+func TestResolveConfiguredPlugins_UnknownDisabledWarns(t *testing.T) {
+	cfg := config.DefaultConfig()
+	cfg.Plugins = config.PluginsConfig{
+		DefaultEnabled: true,
+		Enabled:        []string{},
+		Disabled:       []string{"missing-plugin"},
+	}
+
+	instances, summary, err := ResolveConfiguredPlugins(cfg)
+	if err != nil {
+		t.Fatalf("ResolveConfiguredPlugins() error = %v", err)
+	}
+
+	expectedEnabled := builtin.Names()
+	if !slices.Equal(pluginNames(instances), expectedEnabled) {
+		t.Fatalf("plugin names mismatch: got %v, want %v", pluginNames(instances), expectedEnabled)
+	}
+	if !slices.Equal(summary.UnknownDisabled, []string{"missing-plugin"}) {
+		t.Fatalf("UnknownDisabled mismatch: got %v", summary.UnknownDisabled)
+	}
+	if !hasWarningSubstring(summary.Warnings, `unknown disabled plugin "missing-plugin" ignored`) {
+		t.Fatalf("expected unknown disabled warning, got %v", summary.Warnings)
+	}
+}
+
+func pluginNames(instances []plugin.Plugin) []string {
+	names := make([]string, 0, len(instances))
+	for _, instance := range instances {
+		names = append(names, instance.Name())
+	}
+	return names
+}
+
+func hasWarningSubstring(warnings []string, sub string) bool {
+	for _, warning := range warnings {
+		if strings.Contains(warning, sub) {
+			return true
+		}
+	}
+	return false
+}