Simplify plugin manager (#299)

* Simplify plugin manager

Removed all the cruft trying to assume and change naming.
Removed legacy stuff around list or dict handling
Added simple name sense probe on plugin sync / add / remove

Signed-off-by: Luke Hinds <[email protected]>

* Mark nosec for non concerning pass

* Optimise from review

---------

Signed-off-by: Luke Hinds <[email protected]>

Author: lukehinds

src/agent/cli/commands/plugin_manage.py

@@ -11,6 +11,62 @@
 logger = structlog.get_logger(__name__)
 
 
+def _find_similar_plugin_names(target_name: str, available_names: list[str], max_suggestions: int = 3) -> list[str]:
+    """Find similar plugin names using simple string similarity."""
+    if not available_names:
+        return []
+
+    suggestions = []
+
+    # 1. Exact match (case-insensitive)
+    for name in available_names:
+        if name.lower() == target_name.lower():
+            return [name]  # Exact match found
+
+    # 2. Simple character replacement (- <-> _)
+    target_normalized = target_name.replace("_", "-")
+    for name in available_names:
+        name_normalized = name.replace("_", "-")
+        if target_normalized.lower() == name_normalized.lower():
+            suggestions.append(name)
+
+    # 3. Basic edit distance for other close matches
+    if len(suggestions) < max_suggestions:
+
+        def simple_edit_distance(s1: str, s2: str) -> int:
+            """Simple Levenshtein distance calculation."""
+            if len(s1) < len(s2):
+                return simple_edit_distance(s2, s1)
+            if len(s2) == 0:
+                return len(s1)
+
+            previous_row = list(range(len(s2) + 1))
+            for i, c1 in enumerate(s1):
+                current_row = [i + 1]
+                for j, c2 in enumerate(s2):
+                    insertions = previous_row[j + 1] + 1
+                    deletions = current_row[j] + 1
+                    substitutions = previous_row[j] + (c1 != c2)
+                    current_row.append(min(insertions, deletions, substitutions))
+                previous_row = current_row
+            return previous_row[-1]
+
+        # Calculate similarity for remaining names
+        similarities = []
+        for name in available_names:
+            if name not in suggestions:
+                distance = simple_edit_distance(target_name.lower(), name.lower())
+                # Only suggest if distance is reasonable (less than half the length)
+                if distance <= min(len(target_name), len(name)) // 2:
+                    similarities.append((name, distance))
+
+        # Sort by distance and add to suggestions
+        similarities.sort(key=lambda x: x[1])
+        suggestions.extend([name for name, _ in similarities[: max_suggestions - len(suggestions)]])
+
+    return suggestions[:max_suggestions]
+
+
 @click.command()
 @click.option("--dry-run", is_flag=True, help="Show what would be changed without making changes")
 @click.pass_context
@@ -86,8 +142,8 @@ def sync(ctx, dry_run: bool):
                     fg="yellow",
                 )
 
-            installed_plugins[plugin_info["package"]] = {
-                "plugin_name": plugin_name,
+            installed_plugins[plugin_name] = {
+                "package_name": plugin_info["package"],
                 "version": plugin_info["version"],
                 "capabilities": capabilities,
             }
@@ -98,46 +154,41 @@ def sync(ctx, dry_run: bool):
         click.secho(f"Failed to discover installed plugins: {e}", fg="red")
         ctx.exit(1)
 
-    # Calculate changes needed - use package names for consistent comparison
-    installed_package_names = set(installed_plugins.keys())
+    # Calculate changes needed - use plugin (entry point) names for comparison
+    installed_plugin_names = set(installed_plugins.keys())
 
     # Plugins to add (installed but not in config)
-    packages_to_add = installed_package_names - current_plugins
+    plugins_to_add = installed_plugin_names - current_plugins
 
     # Plugins to remove (in config but not installed)
-    packages_to_remove = current_plugins - installed_package_names
+    plugins_to_remove = current_plugins - installed_plugin_names
 
-    # Get packages to add (package names that need to be added)
-    plugins_to_add = []
-    for package_name, info in installed_plugins.items():
-        if package_name in packages_to_add:
-            plugins_to_add.append((info["plugin_name"], package_name))
-
-    # Keep package names for removals since that's how they're stored in config
-    packages_to_remove_list = list(packages_to_remove)
+    # Convert to list for processing
+    plugins_to_add_list = list(plugins_to_add)
+    plugins_to_remove_list = list(plugins_to_remove)
 
     # Show summary of changes
-    if plugins_to_add:
-        click.secho(f"\nPlugins to add ({len(plugins_to_add)}):", fg="green")
-        for plugin_name, package_name in sorted(plugins_to_add):
-            package_info = installed_plugins[package_name]
+    if plugins_to_add_list:
+        click.secho(f"\nPlugins to add ({len(plugins_to_add_list)}):", fg="green")
+        for plugin_name in sorted(plugins_to_add_list):
+            plugin_info = installed_plugins[plugin_name]
             click.secho(
-                f"  + {package_name} (plugin: {plugin_name}, v{package_info['version']})",
+                f"  + {plugin_name} (package: {plugin_info['package_name']}, v{plugin_info['version']})",
                 fg="green",
             )
 
-    if packages_to_remove_list:
-        click.secho(f"\nPlugins to remove ({len(packages_to_remove_list)}):", fg="red")
-        for package_name in sorted(packages_to_remove_list):
-            click.secho(f"  - {package_name} (package no longer installed)", fg="red")
+    if plugins_to_remove_list:
+        click.secho(f"\nPlugins to remove ({len(plugins_to_remove_list)}):", fg="red")
+        for plugin_name in sorted(plugins_to_remove_list):
+            click.secho(f"  - {plugin_name} (plugin no longer installed)", fg="red")
 
-    if not plugins_to_add and not packages_to_remove_list:
+    if not plugins_to_add_list and not plugins_to_remove_list:
         click.secho("\n✓ agentup.yml is already in sync with installed plugins", fg="green")
         return
 
     if dry_run:
         click.secho(
-            f"\nWould add {len(plugins_to_add)} and remove {len(packages_to_remove_list)} plugins",
+            f"\nWould add {len(plugins_to_add_list)} and remove {len(plugins_to_remove_list)} plugins",
             fg="cyan",
         )
         click.secho("Run without --dry-run to apply changes", fg="cyan")
@@ -147,11 +198,11 @@ def sync(ctx, dry_run: bool):
     changes_made = False
 
     # Add new plugins with discovered capabilities
-    for _plugin_name, package_name in plugins_to_add:
+    for plugin_name in plugins_to_add_list:
         try:
-            plugin_info = installed_plugins[package_name]
+            plugin_info = installed_plugins[plugin_name]
 
-            # Create plugin override with package name and capabilities
+            # Create plugin override with capabilities
             from agent.config.intent import CapabilityOverride, PluginOverride
 
             capability_overrides = {}
@@ -161,45 +212,45 @@ def sync(ctx, dry_run: bool):
                         enabled=cap["enabled"], required_scopes=cap["required_scopes"]
                     )
 
-            # Create plugin override (package name is the key)
+            # Create plugin override (plugin name is the key)
             plugin_override = PluginOverride(
                 enabled=True,
                 capabilities=capability_overrides,
             )
-            # Use package name as key for intuitive user experience
-            intent_config.add_plugin(package_name, plugin_override)
+            # Use plugin (entry point) name as key to match plugin loading logic
+            intent_config.add_plugin(plugin_name, plugin_override)
 
             if plugin_info["capabilities"]:
                 click.secho(
-                    f"  ✓ Added {package_name} with {len(plugin_info['capabilities'])} capabilities",
+                    f"  ✓ Added {plugin_name} (from {plugin_info['package_name']}) with {len(plugin_info['capabilities'])} capabilities",
                     fg="green",
                 )
             else:
                 click.secho(
-                    f"  ✓ Added {package_name} with no capabilities",
+                    f"  ✓ Added {plugin_name} (from {plugin_info['package_name']}) with no capabilities",
                     fg="green",
                 )
 
             changes_made = True
         except (KeyError, AttributeError, ValueError, TypeError) as e:
-            click.secho(f"  ✗ Failed to add {package_name}: {e}", fg="red")
+            click.secho(f"  ✗ Failed to add {plugin_name}: {e}", fg="red")
 
     # Remove plugins no longer installed
-    for package_name in packages_to_remove_list:
+    for plugin_name in plugins_to_remove_list:
         try:
-            if package_name in intent_config.plugins:
-                del intent_config.plugins[package_name]
-                click.secho(f"  ✓ Removed {package_name}", fg="green")
+            if plugin_name in intent_config.plugins:
+                del intent_config.plugins[plugin_name]
+                click.secho(f"  ✓ Removed {plugin_name}", fg="green")
                 changes_made = True
         except (KeyError, AttributeError) as e:
-            click.secho(f"  ✗ Failed to remove {package_name}: {e}", fg="red")
+            click.secho(f"  ✗ Failed to remove {plugin_name}: {e}", fg="red")
 
     # Save updated configuration
     if changes_made:
         try:
             save_intent_config(intent_config, str(intent_config_path))
             click.secho(
-                f"\n✓ Updated agentup.yml with {len(plugins_to_add)} additions and {len(packages_to_remove_list)} removals",
+                f"\n✓ Updated agentup.yml with {len(plugins_to_add_list)} additions and {len(plugins_to_remove_list)} removals",
                 fg="green",
             )
         except (FileNotFoundError, yaml.YAMLError, PermissionError, OSError) as e:
@@ -274,6 +325,22 @@ def add(ctx, plugin_name: str):
         if not plugin_found:
             click.secho(f"Plugin '{plugin_name}' is not installed or is not an AgentUp plugin", fg="red")
             click.secho(f"Install it first with: uv add {plugin_name}", fg="cyan")
+
+            # Suggest similar plugin names from available installed plugins
+            try:
+                from agent.plugins.manager import PluginRegistry
+
+                registry = PluginRegistry()
+                available_plugins_info = registry.discover_all_available_plugins()
+                available_plugins = [p["name"] for p in available_plugins_info]
+                suggestions = _find_similar_plugin_names(plugin_name, available_plugins)
+                if suggestions:
+                    if len(suggestions) == 1:
+                        click.secho(f"Did you mean: {suggestions[0]}?", fg="cyan")
+                    else:
+                        click.secho(f"Did you mean one of: {', '.join(suggestions)}?", fg="cyan")
+            except Exception:
+                pass  # nosec
             return
 
         click.secho(
@@ -285,16 +352,62 @@ def add(ctx, plugin_name: str):
         click.secho(f"Failed to verify plugin installation: {e}", fg="red")
         ctx.exit(1)
 
-    # Add plugin to configuration (package name is used as the key)
+    # Add plugin to configuration with capability discovery
     try:
-        from agent.config.intent import PluginOverride
+        from agent.config.intent import CapabilityOverride, PluginOverride
+
+        # Discover capabilities from the plugin (same logic as sync)
+        capability_overrides = {}
+
+        try:
+            # Load the plugin and discover capabilities
+            import importlib.metadata as metadata
+
+            entry_points = metadata.entry_points()
+            if hasattr(entry_points, "select"):
+                plugin_entries = entry_points.select(group="agentup.plugins")
+            else:
+                plugin_entries = entry_points.get("agentup.plugins", [])
+
+            for entry_point in plugin_entries:
+                if entry_point.name == actual_plugin_name:
+                    plugin_class = entry_point.load()
+                    plugin_instance = plugin_class()
+
+                    # Get capability definitions if available
+                    if hasattr(plugin_instance, "get_capability_definitions"):
+                        cap_definitions = plugin_instance.get_capability_definitions()
+
+                        for cap_def in cap_definitions:
+                            capability_overrides[cap_def.id] = CapabilityOverride(
+                                enabled=True, required_scopes=cap_def.required_scopes
+                            )
+                    break
+        except (ImportError, AttributeError, TypeError, ValueError) as e:
+            click.secho(
+                f"  Warning: Could not discover capabilities for {actual_plugin_name}: {e}",
+                fg="yellow",
+            )
 
-        plugin_override = PluginOverride(enabled=True)
+        plugin_override = PluginOverride(
+            enabled=True,
+            capabilities=capability_overrides,
+        )
 
-        # Use package name as key for consistent user experience
-        intent_config.add_plugin(package_name, plugin_override)
+        # Use plugin (entry point) name as key to match plugin loading logic
+        intent_config.add_plugin(actual_plugin_name, plugin_override)
         save_intent_config(intent_config, str(intent_config_path))
-        click.secho(f"✓ Added {package_name} to agentup.yml", fg="green")
+
+        if capability_overrides:
+            click.secho(
+                f"✓ Added {actual_plugin_name} (from package {package_name}) with {len(capability_overrides)} capabilities to agentup.yml",
+                fg="green",
+            )
+        else:
+            click.secho(
+                f"✓ Added {actual_plugin_name} (from package {package_name}) with no capabilities to agentup.yml",
+                fg="green",
+            )
 
     except (
         KeyError,
@@ -330,6 +443,17 @@ def remove(ctx, plugin_name: str):
     # Check if plugin is configured
     if not intent_config.plugins or plugin_name not in intent_config.plugins:
         click.secho(f"Plugin '{plugin_name}' is not configured in agentup.yml", fg="yellow")
+
+        # Suggest similar plugin names from configured plugins
+        if intent_config.plugins:
+            configured_plugins = list(intent_config.plugins.keys())
+            suggestions = _find_similar_plugin_names(plugin_name, configured_plugins)
+            if suggestions:
+                if len(suggestions) == 1:
+                    click.secho(f"Did you mean: {suggestions[0]}?", fg="cyan")
+                else:
+                    click.secho(f"Did you mean one of: {', '.join(suggestions)}?", fg="cyan")
+
         return
 
     # Remove the plugin
@@ -365,15 +489,9 @@ def reload(plugin_name: str):
             click.secho(f"Plugin '{plugin_name}' not found", fg="yellow")
             return
 
-        click.secho(f"Reloading plugin '{plugin_name}'...", fg="cyan")
-
-        if manager.reload_plugin(plugin_name):
-            click.secho(f"✓ Successfully reloaded {plugin_name}", fg="green")
-        else:
-            click.secho(f"✗ Failed to reload {plugin_name}", fg="red")
-            click.secho("[dim]Note: Entry point plugins cannot be reloaded[/dim]")
+        click.secho("Restart the agent to reload plugin changes.", fg="cyan")
 
     except ImportError:
         click.secho("Plugin system not available.", fg="red")
     except (AttributeError, KeyError, RuntimeError) as e:
-        click.secho(f"Error reloading plugin: {e}", fg="red")
+        click.secho(f"Error accessing plugin: {e}", fg="red")

src/agent/config/model.py

@@ -495,24 +495,6 @@ def name(self) -> str:
     middleware: MiddlewareConfig = Field(default_factory=MiddlewareConfig)
     mcp: MCPConfig = Field(default_factory=MCPConfig)
 
-    @field_validator("plugins", mode="before")
-    @classmethod
-    def validate_plugins_format(cls, v):
-        """Convert list format to dict format for backward compatibility."""
-        if isinstance(v, list):
-            # Convert list format to dict format using package names as keys
-            plugin_dict = {}
-            for plugin_config in v:
-                if isinstance(plugin_config, dict) and "name" in plugin_config:
-                    plugin_name = plugin_config["name"]
-                    # Use the plugin name as key, store the rest as config
-                    plugin_dict[plugin_name] = plugin_config
-                else:
-                    # Handle invalid plugin config
-                    continue
-            return plugin_dict
-        return v
-
     # AI configuration
     ai: dict[str, Any] = Field(default_factory=dict, description="AI settings")
     ai_provider: dict[str, Any] = Field(default_factory=dict, description="AI provider configuration")