hanuscode 1.0.0__py3-none-any.whl

hanus/plugin_manager.py

@@ -0,0 +1,754 @@
+# plugin_manager.py
+"""Dynamic plugin loading from /plugins folder with enable/disable support and hot-reload."""
+from __future__ import annotations
+import importlib.util
+import traceback
+import json
+import threading
+import time
+import hashlib
+import requests
+from pathlib import Path
+from typing import Dict, Optional, Any, Set, Callable, List
+from dataclasses import dataclass
+from datetime import datetime
+
+
+# Official plugins repository
+PLUGINS_REPO_URL = "https://raw.githubusercontent.com/hanuscode/hanuscode-plugins/main/plugins"
+PLUGINS_REPO_PAGE = "https://github.com/hanuscode/hanuscode-plugins/tree/main/plugins"
+
+
+@dataclass
+class PluginFileState:
+    """Estado de un archivo de plugin para detectar cambios."""
+    path: Path
+    mtime: float
+    size: int
+    hash: str
+
+
+class Plugin:
+    def __init__(self, module: Any, path: Path):
+        self.module = module
+        self.path = path
+        self.name = getattr(module, "NAME", path.stem)
+        self.description = getattr(module, "DESCRIPTION", "No description")
+        self.usage = getattr(module, "USAGE", "")
+        self.enabled = True  # Default to enabled
+        self.loaded_at = time.time()
+        self.file_hash = self._compute_file_hash()
+
+    def _compute_file_hash(self) -> str:
+        """Computa hash del archivo fuente para detectar cambios."""
+        try:
+            content = self.path.read_bytes()
+            return hashlib.md5(content).hexdigest()
+        except Exception:
+            return ""
+
+    def run(self, args: str = "") -> str:
+        if not self.enabled:
+            return f"[Plugin {self.name}] Plugin is disabled. Use '/plugins enable {self.name}' to enable."
+        try:
+            fn = getattr(self.module, "run", None)
+            return str(fn(args)) if callable(fn) else f"[Plugin {self.name}] No run() function"
+        except Exception as e:
+            return f"[Plugin {self.name}] Error: {e}\n{traceback.format_exc()}"
+
+    def get_doc(self) -> str:
+        status = "✓" if self.enabled else "✗"
+        lines = [
+            f"### Plugin: {self.name} [{status}]",
+            f"**Description:** {self.description}",
+            f"**Usage:** `<run_plugin name=\"{self.name}\" args=\"{self.usage}\"/>`",
+        ]
+        extra = getattr(self.module, "AGENT_DOC", "")
+        if extra:
+            lines.append(extra)
+        return "\n".join(lines)
+
+    def needs_reload(self) -> bool:
+        """Verifica si el archivo del plugin ha cambiado."""
+        try:
+            if not self.path.exists():
+                return False
+            current_hash = self._compute_file_hash()
+            return current_hash != self.file_hash
+        except Exception:
+            return False
+
+
+class PluginManager:
+    CONFIG_FILE = Path.home() / ".hanus" / "plugins_config.json"
+
+    def __init__(self, plugins_dir: Path, enable_hot_reload: bool = True):
+        self.plugins_dir = plugins_dir
+        self.plugins: Dict[str, Plugin] = {}
+        self.disabled_plugins: Set[str] = set()  # Set of disabled plugin names
+
+        # Hot-reload support - inicializar ANTES de cargar plugins
+        self._enable_hot_reload = enable_hot_reload
+        self._file_states: Dict[str, PluginFileState] = {}
+        self._watcher_thread: Optional[threading.Thread] = None
+        self._watcher_running = False
+        self._reload_callbacks: List[Callable[[str, str], None]] = []  # (event, plugin_name)
+
+        # Callbacks para notificar a WebUI
+        self._ui_notify_callback: Optional[Callable[[str, Any], None]] = None
+
+        # Cargar configuración y plugins
+        self._load_config()
+        self._load_all()
+
+        # Iniciar watcher si está habilitado
+        if enable_hot_reload:
+            self.start_hot_reload_watcher()
+
+    def _init_file_states(self) -> None:
+        """Inicializa los estados de los archivos de plugins."""
+        for name, plugin in self.plugins.items():
+            try:
+                stat = plugin.path.stat()
+                self._file_states[name] = PluginFileState(
+                    path=plugin.path,
+                    mtime=stat.st_mtime,
+                    size=stat.st_size,
+                    hash=plugin.file_hash
+                )
+            except Exception:
+                pass
+
+    # ══════════════════════════════════════════════════════════════════════════
+    # HOT-RELOAD API
+    # ══════════════════════════════════════════════════════════════════════════
+
+    def start_hot_reload_watcher(self, interval: float = 2.0) -> None:
+        """
+        Inicia el watcher para detectar cambios en plugins.
+
+        Args:
+            interval: Intervalo en segundos entre chequeos
+        """
+        if self._watcher_running:
+            return
+
+        self._watcher_running = True
+        self._watcher_thread = threading.Thread(
+            target=self._watcher_loop,
+            args=(interval,),
+            daemon=True
+        )
+        self._watcher_thread.start()
+
+    def stop_hot_reload_watcher(self) -> None:
+        """Detiene el watcher de hot-reload."""
+        self._watcher_running = False
+        if self._watcher_thread:
+            self._watcher_thread.join(timeout=5.0)
+            self._watcher_thread = None
+
+    def reload_plugin(self, name: str) -> bool:
+        """
+        Recarga un plugin específico.
+
+        Args:
+            name: Nombre del plugin a recargar
+
+        Returns:
+            True si se recargó correctamente
+        """
+        if name not in self.plugins:
+            return False
+
+        plugin = self.plugins[name]
+        was_enabled = plugin.enabled
+
+        try:
+            # Recargar el módulo
+            spec = importlib.util.spec_from_file_location(
+                f"hanus_plugin_{plugin.path.stem}",
+                plugin.path
+            )
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+
+            # Crear nuevo plugin
+            new_plugin = Plugin(module, plugin.path)
+            new_plugin.enabled = was_enabled
+
+            # Actualizar
+            self.plugins[name] = new_plugin
+
+            # Actualizar estado de archivo
+            stat = plugin.path.stat()
+            self._file_states[name] = PluginFileState(
+                path=plugin.path,
+                mtime=stat.st_mtime,
+                size=stat.st_size,
+                hash=new_plugin.file_hash
+            )
+
+            # Notificar callbacks
+            self._notify_reload("reloaded", name)
+
+            return True
+
+        except Exception as e:
+            print(f"[PluginManager] Error reloading '{name}': {e}")
+            self._notify_reload("reload_error", f"{name}: {e}")
+            return False
+
+    def add_reload_callback(self, callback: Callable[[str, str], None]) -> None:
+        """
+        Añade un callback para eventos de reload.
+
+        Args:
+            callback: Función que recibe (event_type, plugin_name)
+        """
+        self._reload_callbacks.append(callback)
+
+    def set_ui_notify_callback(self, callback: Callable[[str, Any], None]) -> None:
+        """
+        Establece un callback para notificar a la UI.
+
+        Args:
+            callback: Función que recibe (event_type, data)
+        """
+        self._ui_notify_callback = callback
+
+    def get_hot_reload_status(self) -> Dict[str, Any]:
+        """Retorna el estado del sistema de hot-reload."""
+        return {
+            "enabled": self._enable_hot_reload,
+            "running": self._watcher_running,
+            "plugins_watched": len(self._file_states),
+            "last_check": datetime.now().isoformat() if self._watcher_running else None,
+        }
+
+    # ══════════════════════════════════════════════════════════════════════════
+    # PLUGIN INSTALLATION FROM REPOSITORY
+    # ══════════════════════════════════════════════════════════════════════════
+
+    def install_plugin(self, name: str, force: bool = False) -> Dict[str, Any]:
+        """
+        Install a plugin from the official repository.
+
+        Args:
+            name: Plugin name (without .py extension)
+            force: Overwrite if already exists
+
+        Returns:
+            Dict with 'success', 'message', and optionally 'error' keys
+        """
+        # Sanitize plugin name
+        safe_name = "".join(c for c in name.lower() if c.isalnum() or c in "_-")
+        if not safe_name:
+            return {"success": False, "error": "Invalid plugin name"}
+
+        # Check if already installed
+        if safe_name in self.plugins and not force:
+            return {
+                "success": False,
+                "error": f"Plugin '{safe_name}' is already installed. Use --force to overwrite."
+            }
+
+        # Build URL
+        url = f"{PLUGINS_REPO_URL}/{safe_name}.py"
+
+        try:
+            # Download plugin
+            response = requests.get(url, timeout=30)
+            response.raise_for_status()
+
+            # Validate content is Python code
+            content = response.text
+            if not content.strip():
+                return {"success": False, "error": "Downloaded file is empty"}
+
+            # Basic validation - check for required attributes
+            if "NAME =" not in content and "NAME=" not in content:
+                return {
+                    "success": False,
+                    "error": "Invalid plugin format: missing NAME attribute"
+                }
+
+            # Save to plugins directory
+            plugin_path = self.plugins_dir / f"{safe_name}.py"
+            plugin_path.write_text(content, encoding="utf-8")
+
+            # Load the plugin
+            self._load(plugin_path)
+
+            if safe_name in self.plugins:
+                return {
+                    "success": True,
+                    "message": f"✓ Plugin '{safe_name}' installed successfully!\n\n{self.plugins[safe_name].get_doc()}"
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": f"Plugin downloaded but failed to load. Check for syntax errors."
+                }
+
+        except requests.exceptions.HTTPError as e:
+            if e.response.status_code == 404:
+                return {
+                    "success": False,
+                    "error": f"Plugin '{safe_name}' not found in repository.\n\nBrowse plugins at: {PLUGINS_REPO_PAGE}"
+                }
+            return {"success": False, "error": f"HTTP error: {e}"}
+
+        except requests.exceptions.RequestException as e:
+            return {"success": False, "error": f"Network error: {e}"}
+
+        except Exception as e:
+            return {"success": False, "error": f"Error installing plugin: {e}"}
+
+    def uninstall_plugin(self, name: str) -> Dict[str, Any]:
+        """
+        Uninstall a plugin by removing its file.
+
+        Args:
+            name: Plugin name to uninstall
+
+        Returns:
+            Dict with 'success' and 'message' keys
+        """
+        if name not in self.plugins:
+            return {"success": False, "error": f"Plugin '{name}' is not installed"}
+
+        plugin = self.plugins[name]
+
+        # Don't allow uninstalling builtin plugins
+        if "hanus/plugins" in str(plugin.path) and "site-packages" not in str(plugin.path):
+            # Check if it's in the package plugins directory
+            try:
+                import hanus
+                pkg_dir = Path(hanus.__file__).parent / "plugins"
+                if plugin.path.parent == pkg_dir:
+                    return {
+                        "success": False,
+                        "error": f"Cannot uninstall builtin plugin '{name}'. Use 'disable' instead."
+                    }
+            except ImportError:
+                pass
+
+        try:
+            # Remove from plugins dict
+            del self.plugins[name]
+
+            # Remove from disabled set if present
+            self.disabled_plugins.discard(name)
+
+            # Remove file
+            if plugin.path.exists():
+                plugin.path.unlink()
+
+            # Remove from file states
+            if name in self._file_states:
+                del self._file_states[name]
+
+            # Save config
+            self._save_config()
+
+            return {"success": True, "message": f"✓ Plugin '{name}' uninstalled successfully"}
+
+        except Exception as e:
+            return {"success": False, "error": f"Error uninstalling plugin: {e}"}
+
+    def list_available_plugins(self) -> Dict[str, Any]:
+        """
+        List plugins available in the repository.
+
+        Returns:
+            Dict with 'success', 'plugins' list, and optionally 'error'
+        """
+        try:
+            # Try to fetch the directory listing from GitHub API
+            api_url = "https://api.github.com/repos/hanuscode/hanuscode-plugins/contents/plugins"
+            response = requests.get(api_url, timeout=30)
+
+            if response.status_code == 200:
+                files = response.json()
+                plugins = []
+                for f in files:
+                    if f["name"].endswith(".py") and not f["name"].startswith("_"):
+                        plugins.append({
+                            "name": f["name"][:-3],  # Remove .py
+                            "url": f["html_url"],
+                            "size": f.get("size", 0),
+                        })
+                return {"success": True, "plugins": plugins}
+            else:
+                # Fallback: return basic info
+                return {
+                    "success": True,
+                    "plugins": [],
+                    "message": f"Could not fetch plugin list. Browse at: {PLUGINS_REPO_PAGE}"
+                }
+
+        except Exception as e:
+            return {
+                "success": True,
+                "plugins": [],
+                "message": f"Could not fetch plugin list: {e}\n\nBrowse at: {PLUGINS_REPO_PAGE}"
+            }
+
+    def update_plugin(self, name: str) -> Dict[str, Any]:
+        """
+        Update a plugin to the latest version from repository.
+
+        Args:
+            name: Plugin name to update
+
+        Returns:
+            Dict with 'success' and 'message' keys
+        """
+        if name not in self.plugins:
+            return {"success": False, "error": f"Plugin '{name}' is not installed"}
+
+        return self.install_plugin(name, force=True)
+
+    # ══════════════════════════════════════════════════════════════════════════
+    # MÉTODOS PRIVADOS HOT-RELOAD
+    # ══════════════════════════════════════════════════════════════════════════
+
+    def _watcher_loop(self, interval: float) -> None:
+        """Loop principal del watcher de archivos."""
+        while self._watcher_running:
+            try:
+                self._check_for_changes()
+                self._check_for_new_plugins()
+            except Exception as e:
+                print(f"[PluginManager] Watcher error: {e}")
+
+            time.sleep(interval)
+
+    def _check_for_changes(self) -> None:
+        """Verifica si algún plugin ha cambiado."""
+        for name, plugin in list(self.plugins.items()):
+            try:
+                if not plugin.path.exists():
+                    continue
+
+                stat = plugin.path.stat()
+                old_state = self._file_states.get(name)
+
+                if old_state is None:
+                    continue
+
+                # Verificar cambios por mtime y tamaño
+                if (stat.st_mtime != old_state.mtime or
+                    stat.st_size != old_state.size):
+
+                    # Verificar hash para confirmar cambio real
+                    current_hash = plugin._compute_file_hash()
+                    if current_hash != old_state.hash:
+                        print(f"[PluginManager] Detected change in '{name}', reloading...")
+                        self.reload_plugin(name)
+
+            except Exception:
+                pass
+
+    def _check_for_new_plugins(self) -> None:
+        """Verifica si hay nuevos plugins en el directorio."""
+        if not self.plugins_dir.exists():
+            return
+
+        for py in self.plugins_dir.glob("*.py"):
+            if py.name.startswith("_"):
+                continue
+
+            name = py.stem
+            if name not in self.plugins:
+                print(f"[PluginManager] New plugin detected: '{name}'")
+                self._load(py)
+                self._notify_reload("added", name)
+
+    def _notify_reload(self, event: str, plugin_name: str) -> None:
+        """Notifica a los callbacks sobre un evento de reload."""
+        # Callbacks locales
+        for callback in self._reload_callbacks:
+            try:
+                callback(event, plugin_name)
+            except Exception:
+                pass
+
+        # Callback de UI
+        if self._ui_notify_callback:
+            try:
+                self._ui_notify_callback("plugin_reload", {
+                    "event": event,
+                    "plugin": plugin_name,
+                    "timestamp": datetime.now().isoformat()
+                })
+            except Exception:
+                pass
+
+    # ══════════════════════════════════════════════════════════════════════════
+    # MÉTODOS ORIGINALES
+    # ══════════════════════════════════════════════════════════════════════════
+
+    def _load_config(self):
+        """Load plugin configuration from file."""
+        if self.CONFIG_FILE.exists():
+            try:
+                config = json.loads(self.CONFIG_FILE.read_text(encoding="utf-8"))
+                self.disabled_plugins = set(config.get("disabled", []))
+            except Exception as e:
+                print(f"  [PluginManager] Error loading config: {e}")
+                self.disabled_plugins = set()
+
+    def _save_config(self):
+        """Save plugin configuration to file."""
+        self.CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+        config = {
+            "disabled": list(self.disabled_plugins)
+        }
+        self.CONFIG_FILE.write_text(json.dumps(config, indent=2), encoding="utf-8")
+
+    def _load_all(self):
+        """Load all plugins from directory."""
+        self.plugins.clear()
+        if not self.plugins_dir.exists():
+            return
+        for py in sorted(self.plugins_dir.glob("*.py")):
+            if not py.name.startswith("_"):
+                self._load(py)
+
+    def _load(self, path: Path):
+        """Load a single plugin."""
+        try:
+            spec = importlib.util.spec_from_file_location(f"hanus_plugin_{path.stem}", path)
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            p = Plugin(module, path)
+
+            # Apply saved state
+            p.enabled = p.name not in self.disabled_plugins
+
+            self.plugins[p.name] = p
+
+            # Guardar estado de archivo para hot-reload
+            stat = path.stat()
+            self._file_states[p.name] = PluginFileState(
+                path=path,
+                mtime=stat.st_mtime,
+                size=stat.st_size,
+                hash=p.file_hash
+            )
+
+        except Exception as e:
+            print(f"  [PluginManager] Error loading '{path.name}': {e}")
+
+    def reload(self):
+        """Reload all plugins."""
+        self._load_config()
+        self._load_all()
+
+    def enable(self, name: str) -> bool:
+        """Enable a plugin."""
+        if name not in self.plugins:
+            return False
+        self.plugins[name].enabled = True
+        self.disabled_plugins.discard(name)
+        self._save_config()
+        return True
+
+    def disable(self, name: str) -> bool:
+        """Disable a plugin."""
+        if name not in self.plugins:
+            return False
+        self.plugins[name].enabled = False
+        self.disabled_plugins.add(name)
+        self._save_config()
+        return True
+
+    def toggle(self, name: str) -> Optional[bool]:
+        """Toggle a plugin. Returns new state or None if not found."""
+        if name not in self.plugins:
+            return None
+        if self.plugins[name].enabled:
+            self.disable(name)
+            return False
+        else:
+            self.enable(name)
+            return True
+
+    def is_enabled(self, name: str) -> bool:
+        """Check if a plugin is enabled."""
+        if name not in self.plugins:
+            return False
+        return self.plugins[name].enabled
+
+    def run(self, name: str, args: str = "") -> Optional[str]:
+        """Run a plugin by name."""
+        p = self.plugins.get(name)
+        if p is None:
+            return f"[Error] Plugin '{name}' not found. Available: {list(self.plugins.keys())}"
+        if not p.enabled:
+            return f"[Error] Plugin '{name}' is disabled. Use '/plugins enable {name}' to enable."
+        return p.run(args)
+
+    def get_plugin_docs(self) -> str:
+        """Get documentation for all enabled plugins."""
+        enabled_plugins = [p for p in self.plugins.values() if p.enabled]
+        if not enabled_plugins:
+            return ""
+        return "\n\n".join(["## Available Plugins\n"] + [p.get_doc() for p in enabled_plugins])
+
+    def get_all_plugin_docs(self) -> str:
+        """Get documentation for ALL plugins (including disabled)."""
+        if not self.plugins:
+            return ""
+        return "\n\n".join(["## All Plugins\n"] + [p.get_doc() for p in self.plugins.values()])
+
+    def get_commands(self) -> Dict[str, str]:
+        """Get dict of plugin names to descriptions (enabled only)."""
+        return {n: p.description for n, p in self.plugins.items() if p.enabled}
+
+    def get_all_commands(self) -> Dict[str, str]:
+        """Get dict of ALL plugin names to descriptions."""
+        return {n: p.description for n, p in self.plugins.items()}
+
+    def list_plugins(self) -> str:
+        """List all plugins with their status."""
+        if not self.plugins:
+            return "No plugins loaded."
+
+        lines = ["Loaded Plugins:", "=" * 50]
+
+        # Enabled plugins first
+        enabled = [(n, p) for n, p in self.plugins.items() if p.enabled]
+        disabled = [(n, p) for n, p in self.plugins.items() if not p.enabled]
+
+        if enabled:
+            lines.append("\n✓ Enabled:")
+            for name, plugin in sorted(enabled):
+                reload_status = " [changed]" if plugin.needs_reload() else ""
+                lines.append(f"  • {name}: {plugin.description}{reload_status}")
+
+        if disabled:
+            lines.append("\n✗ Disabled:")
+            for name, plugin in sorted(disabled):
+                lines.append(f"  • {name}: {plugin.description}")
+
+        lines.append(f"\nTotal: {len(self.plugins)} plugins ({len(enabled)} enabled, {len(disabled)} disabled)")
+
+        # Añadir estado de hot-reload
+        hr_status = self.get_hot_reload_status()
+        lines.append(f"\nHot-reload: {'✓ active' if hr_status['running'] else '✗ inactive'}")
+
+        return "\n".join(lines)
+
+
+def run_plugin_command(args: str, plugin_mgr: PluginManager) -> str:
+    """Handle /plugins command for managing plugins."""
+    if not args.strip():
+        return plugin_mgr.list_plugins() + "\n\nUsage: /plugins <install|uninstall|update|available|enable|disable|toggle|reload|list|status> [plugin_name]"
+
+    parts = args.strip().split(maxsplit=1)
+    cmd = parts[0].lower()
+    name = parts[1] if len(parts) > 1 else ""
+
+    if cmd == "list" or cmd == "ls":
+        return plugin_mgr.list_plugins()
+
+    elif cmd == "enable" or cmd == "on":
+        if not name:
+            return "Usage: /plugins enable <plugin_name>\n\nAvailable: " + ", ".join(sorted(plugin_mgr.plugins.keys()))
+        if plugin_mgr.enable(name):
+            return f"✓ Plugin '{name}' enabled."
+        return f"✗ Plugin '{name}' not found.\n\nAvailable: {', '.join(sorted(plugin_mgr.plugins.keys()))}"
+
+    elif cmd == "disable" or cmd == "off":
+        if not name:
+            return "Usage: /plugins disable <plugin_name>\n\nEnabled: " + ", ".join(
+                sorted(n for n, p in plugin_mgr.plugins.items() if p.enabled)
+            )
+        if plugin_mgr.disable(name):
+            return f"✓ Plugin '{name}' disabled."
+        return f"✗ Plugin '{name}' not found."
+
+    elif cmd == "toggle":
+        if not name:
+            return "Usage: /plugins toggle <plugin_name>"
+        result = plugin_mgr.toggle(name)
+        if result is None:
+            return f"✗ Plugin '{name}' not found."
+        status = "enabled" if result else "disabled"
+        return f"✓ Plugin '{name}' {status}."
+
+    elif cmd == "reload":
+        if name:
+            if plugin_mgr.reload_plugin(name):
+                return f"✓ Plugin '{name}' reloaded."
+            return f"✗ Plugin '{name}' not found or error reloading."
+        else:
+            plugin_mgr.reload()
+            return f"✓ All plugins reloaded.\n\n{plugin_mgr.list_plugins()}"
+
+    elif cmd == "status":
+        if name:
+            if name not in plugin_mgr.plugins:
+                return f"Plugin '{name}' not found."
+            p = plugin_mgr.plugins[name]
+            status = "enabled" if p.enabled else "disabled"
+            hot_reload = plugin_mgr.get_hot_reload_status()
+            return f"Plugin: {name}\nStatus: {status}\nDescription: {p.description}\nUsage: {p.usage}\nFile: {p.path}\nHot-reload: {'active' if hot_reload['running'] else 'inactive'}"
+        return plugin_mgr.list_plugins()
+
+    elif cmd == "hot-reload":
+        status = plugin_mgr.get_hot_reload_status()
+        if name == "start":
+            plugin_mgr.start_hot_reload_watcher()
+            return "✓ Hot-reload watcher started."
+        elif name == "stop":
+            plugin_mgr.stop_hot_reload_watcher()
+            return "✓ Hot-reload watcher stopped."
+        else:
+            return f"Hot-reload status: {'active' if status['running'] else 'inactive'}\nPlugins watched: {status['plugins_watched']}\nUsage: /plugins hot-reload start|stop"
+
+    elif cmd == "install" or cmd == "i":
+        if not name:
+            return "Usage: /plugins install <plugin_name>\n\nBrowse plugins: " + PLUGINS_REPO_PAGE
+        result = plugin_mgr.install_plugin(name)
+        if result["success"]:
+            return result["message"]
+        return f"✗ {result['error']}"
+
+    elif cmd == "uninstall" or cmd == "remove" or cmd == "rm":
+        if not name:
+            return "Usage: /plugins uninstall <plugin_name>\n\nInstalled: " + ", ".join(sorted(plugin_mgr.plugins.keys()))
+        result = plugin_mgr.uninstall_plugin(name)
+        if result["success"]:
+            return result["message"]
+        return f"✗ {result['error']}"
+
+    elif cmd == "update" or cmd == "upgrade":
+        if not name:
+            return "Usage: /plugins update <plugin_name>\n\nInstalled: " + ", ".join(sorted(plugin_mgr.plugins.keys()))
+        result = plugin_mgr.update_plugin(name)
+        if result["success"]:
+            return result["message"]
+        return f"✗ {result['error']}"
+
+    elif cmd == "available" or cmd == "browse" or cmd == "search":
+        result = plugin_mgr.list_available_plugins()
+        if result["success"] and result.get("plugins"):
+            lines = ["📦 Available Plugins in Repository:", "=" * 50, ""]
+            for p in result["plugins"]:
+                installed = "✓ [installed]" if p["name"] in plugin_mgr.plugins else ""
+                lines.append(f"  • {p['name']} {installed}")
+            lines.append(f"\nTotal: {len(result['plugins'])} plugins available")
+            lines.append(f"\nInstall with: /plugins install <name>")
+            lines.append(f"Browse at: {PLUGINS_REPO_PAGE}")
+            return "\n".join(lines)
+        elif result.get("message"):
+            return result["message"]
+        else:
+            return f"Browse plugins at: {PLUGINS_REPO_PAGE}"
+
+    else:
+        return f"Unknown command: {cmd}\n\nCommands: install, uninstall, update, available, enable, disable, toggle, reload, list, status, hot-reload"