feat(plugin): phase2 core selection + resolver (1/4)

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
+}

pkg/config/config.go

@@ -53,6 +53,7 @@ type Config struct {
 	Session   SessionConfig   `json:"session,omitempty"`
 	Channels  ChannelsConfig  `json:"channels"`
 	Providers ProvidersConfig `json:"providers,omitempty"`
+	Plugins   PluginsConfig   `json:"plugins,omitempty"`
 	ModelList []ModelConfig   `json:"model_list"` // New model-centric provider configuration
 	Gateway   GatewayConfig   `json:"gateway"`
 	Tools     ToolsConfig     `json:"tools"`
@@ -167,6 +168,12 @@ type SessionConfig struct {
 	IdentityLinks map[string][]string `json:"identity_links,omitempty"`
 }
 
+type PluginsConfig struct {
+	DefaultEnabled bool     `json:"default_enabled"`
+	Enabled        []string `json:"enabled,omitempty"`
+	Disabled       []string `json:"disabled,omitempty"`
+}
+
 type AgentDefaults struct {
 	Workspace           string   `json:"workspace"                       env:"PICOCLAW_AGENTS_DEFAULTS_WORKSPACE"`
 	RestrictToWorkspace bool     `json:"restrict_to_workspace"           env:"PICOCLAW_AGENTS_DEFAULTS_RESTRICT_TO_WORKSPACE"`

pkg/config/config_test.go

@@ -243,6 +243,51 @@ func TestDefaultConfig_Temperature(t *testing.T) {
 	}
 }
 
+func TestDefaultConfig_PluginsDefaults(t *testing.T) {
+	cfg := DefaultConfig()
+
+	if !cfg.Plugins.DefaultEnabled {
+		t.Error("Plugins.DefaultEnabled should be true by default")
+	}
+	if cfg.Plugins.Enabled == nil {
+		t.Error("Plugins.Enabled should be initialized to an empty slice")
+	}
+	if len(cfg.Plugins.Enabled) != 0 {
+		t.Errorf("Plugins.Enabled len = %d, want 0", len(cfg.Plugins.Enabled))
+	}
+	if cfg.Plugins.Disabled == nil {
+		t.Error("Plugins.Disabled should be initialized to an empty slice")
+	}
+	if len(cfg.Plugins.Disabled) != 0 {
+		t.Errorf("Plugins.Disabled len = %d, want 0", len(cfg.Plugins.Disabled))
+	}
+}
+
+func TestConfig_PluginsJSONUnmarshal(t *testing.T) {
+	jsonData := `{
+		"plugins": {
+			"default_enabled": false,
+			"enabled": ["plugin-a", "plugin-b"],
+			"disabled": ["plugin-c"]
+		}
+	}`
+
+	cfg := DefaultConfig()
+	if err := json.Unmarshal([]byte(jsonData), cfg); err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+
+	if cfg.Plugins.DefaultEnabled {
+		t.Error("Plugins.DefaultEnabled = true, want false")
+	}
+	if len(cfg.Plugins.Enabled) != 2 || cfg.Plugins.Enabled[0] != "plugin-a" || cfg.Plugins.Enabled[1] != "plugin-b" {
+		t.Errorf("Plugins.Enabled = %v, want [plugin-a plugin-b]", cfg.Plugins.Enabled)
+	}
+	if len(cfg.Plugins.Disabled) != 1 || cfg.Plugins.Disabled[0] != "plugin-c" {
+		t.Errorf("Plugins.Disabled = %v, want [plugin-c]", cfg.Plugins.Disabled)
+	}
+}
+
 // TestDefaultConfig_Gateway verifies gateway defaults
 func TestDefaultConfig_Gateway(t *testing.T) {
 	cfg := DefaultConfig()

pkg/config/defaults.go

@@ -134,6 +134,11 @@ func DefaultConfig() *Config {
 		Providers: ProvidersConfig{
 			OpenAI: OpenAIProviderConfig{WebSearch: true},
 		},
+		Plugins: PluginsConfig{
+			DefaultEnabled: true,
+			Enabled:        []string{},
+			Disabled:       []string{},
+		},
 		ModelList: []ModelConfig{
 			// ============================================
 			// Add your API key to the model you want to use