hanuscode 1.0.0__py3-none-any.whl

hanus/plugin_registry.py

@@ -0,0 +1,391 @@
+# hanus/plugin_registry.py
+"""
+Plugin Marketplace/Registry.
+
+Permite descubrir e instalar plugins desde GitHub u otras fuentes.
+"""
+from __future__ import annotations
+import json
+import time
+import urllib.request
+import urllib.error
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+
+
+@dataclass
+class PluginInfo:
+    """Información de un plugin disponible."""
+    name: str
+    display_name: str
+    description: str
+    author: str
+    version: str
+    repository: str
+    download_url: str
+    category: str = "general"
+    tags: List[str] = field(default_factory=list)
+    installed: bool = False
+    installed_version: Optional[str] = None
+    stars: int = 0
+    updated: str = ""
+
+    def to_dict(self) -> Dict:
+        return {
+            "name": self.name,
+            "display_name": self.display_name,
+            "description": self.description,
+            "author": self.author,
+            "version": self.version,
+            "repository": self.repository,
+            "category": self.category,
+            "tags": self.tags,
+            "installed": self.installed,
+            "installed_version": self.installed_version,
+            "stars": self.stars,
+            "updated": self.updated,
+        }
+
+
+class PluginRegistry:
+    """
+    Registry de plugins disponibles.
+
+    Features:
+    - Descubrimiento desde GitHub
+    - Instalación con un comando
+    - Actualizaciones
+    - Metadatos de plugins
+    """
+
+    # URL del registry (puede ser GitHub repo o API)
+    REGISTRY_URL = "https://raw.githubusercontent.com/hanuscode/hanuscode-plugins/main/registry.json"
+
+    # Fallback con plugins builtin
+    BUILTIN_REGISTRY = [
+        {
+            "name": "webui",
+            "display_name": "Web UI",
+            "description": "Interfaz web para HanusCode",
+            "author": "hanus",
+            "version": "1.0.0",
+            "category": "core",
+            "tags": ["ui", "web"],
+        },
+        {
+            "name": "cortex",
+            "display_name": "Cortex Memory",
+            "description": "Sistema de memoria semántica con knowledge graphs",
+            "author": "hanus",
+            "version": "1.0.0",
+            "category": "memory",
+            "tags": ["memory", "graph", "ai"],
+        },
+        {
+            "name": "search_code",
+            "display_name": "Code Search",
+            "description": "Búsqueda avanzada de código",
+            "author": "hanus",
+            "version": "1.0.0",
+            "category": "tools",
+            "tags": ["search", "code"],
+        },
+        {
+            "name": "git_ops",
+            "display_name": "Git Operations",
+            "description": "Operaciones de Git avanzadas",
+            "author": "hanus",
+            "version": "1.0.0",
+            "category": "tools",
+            "tags": ["git", "version-control"],
+        },
+        {
+            "name": "strategist",
+            "display_name": "Strategist",
+            "description": "Planificación estratégica de proyectos",
+            "author": "hanus",
+            "version": "1.0.0",
+            "category": "ai",
+            "tags": ["planning", "strategy"],
+        },
+        {
+            "name": "deps_check",
+            "display_name": "Dependency Checker",
+            "description": "Verificación de dependencias",
+            "author": "hanus",
+            "version": "1.0.0",
+            "category": "tools",
+            "tags": ["dependencies", "security"],
+        },
+    ]
+
+    def __init__(self, plugins_dir: Path, cache_dir: Optional[Path] = None):
+        self.plugins_dir = plugins_dir
+        self.cache_dir = cache_dir or (Path.home() / ".hanus" / "registry_cache")
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+        self._cache_file = self.cache_dir / "registry_cache.json"
+        self._cache: Dict[str, PluginInfo] = {}
+        self._last_update = 0
+
+    def fetch_registry(self, force: bool = False) -> List[PluginInfo]:
+        """
+        Obtiene el registry de plugins.
+
+        Args:
+            force: Forzar actualización
+
+        Returns:
+            Lista de plugins disponibles
+        """
+        # Verificar cache
+        if not force and self._cache:
+            if time.time() - self._last_update < 3600:  # 1 hora
+                return list(self._cache.values())
+
+        # Intentar cargar desde disco
+        if not force and self._load_cache():
+            return list(self._cache.values())
+
+        # Intentar obtener de remoto
+        try:
+            plugins = self._fetch_remote()
+            self._update_cache(plugins)
+            return plugins
+        except Exception as e:
+            print(f"[PluginRegistry] Could not fetch remote: {e}")
+            # Usar builtin como fallback
+            plugins = [PluginInfo(
+                name=p["name"],
+                display_name=p.get("display_name", p["name"]),
+                description=p.get("description", ""),
+                author=p.get("author", "unknown"),
+                version=p.get("version", "1.0.0"),
+                repository=p.get("repository", ""),
+                download_url=p.get("download_url", ""),
+                category=p.get("category", "general"),
+                tags=p.get("tags", []),
+            ) for p in self.BUILTIN_REGISTRY]
+            self._update_cache(plugins)
+            return plugins
+
+    def search(self, query: str) -> List[PluginInfo]:
+        """
+        Busca plugins por nombre o descripción.
+
+        Args:
+            query: Texto de búsqueda
+
+        Returns:
+            Lista de plugins que coinciden
+        """
+        plugins = self.fetch_registry()
+        query_lower = query.lower()
+
+        results = []
+        for plugin in plugins:
+            if (query_lower in plugin.name.lower() or
+                query_lower in plugin.description.lower() or
+                query_lower in plugin.display_name.lower() or
+                any(query_lower in tag for tag in plugin.tags)):
+                results.append(plugin)
+
+        return results
+
+    def get_plugin(self, name: str) -> Optional[PluginInfo]:
+        """Obtiene información de un plugin específico."""
+        plugins = self.fetch_registry()
+        for plugin in plugins:
+            if plugin.name == name:
+                # Verificar si está instalado
+                plugin.installed = (self.plugins_dir / f"{name}.py").exists()
+                return plugin
+        return None
+
+    def install(self, name: str) -> Tuple[bool, str]:
+        """
+        Instala un plugin.
+
+        Args:
+            name: Nombre del plugin
+
+        Returns:
+            (success, message)
+        """
+        plugin = self.get_plugin(name)
+        if not plugin:
+            return False, f"Plugin '{name}' not found in registry"
+
+        if plugin.installed:
+            return True, f"Plugin '{name}' is already installed"
+
+        # Si hay URL de descarga
+        if plugin.download_url:
+            try:
+                content = self._download(plugin.download_url)
+                target = self.plugins_dir / f"{name}.py"
+                target.write_text(content, encoding="utf-8")
+                return True, f"Plugin '{name}' installed successfully"
+            except Exception as e:
+                return False, f"Error installing '{name}': {e}"
+
+        # Si no hay URL, crear desde template
+        return False, f"Plugin '{name}' has no download URL. Manual installation required."
+
+    def uninstall(self, name: str) -> Tuple[bool, str]:
+        """
+        Desinstala un plugin.
+
+        Args:
+            name: Nombre del plugin
+
+        Returns:
+            (success, message)
+        """
+        plugin_file = self.plugins_dir / f"{name}.py"
+
+        if not plugin_file.exists():
+            return False, f"Plugin '{name}' is not installed"
+
+        try:
+            plugin_file.unlink()
+            return True, f"Plugin '{name}' uninstalled successfully"
+        except Exception as e:
+            return False, f"Error uninstalling '{name}': {e}"
+
+    def update(self, name: str) -> Tuple[bool, str]:
+        """
+        Actualiza un plugin.
+
+        Args:
+            name: Nombre del plugin
+
+        Returns:
+            (success, message)
+        """
+        plugin = self.get_plugin(name)
+        if not plugin:
+            return False, f"Plugin '{name}' not found"
+
+        if not plugin.installed:
+            return False, f"Plugin '{name}' is not installed"
+
+        # Reinstalar
+        return self.install(name)
+
+    def list_installed(self) -> List[str]:
+        """Lista plugins instalados."""
+        if not self.plugins_dir.exists():
+            return []
+
+        return [
+            p.stem for p in self.plugins_dir.glob("*.py")
+            if not p.name.startswith("_")
+        ]
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Obtiene estadísticas del registry."""
+        plugins = self.fetch_registry()
+        installed = self.list_installed()
+
+        return {
+            "total_plugins": len(plugins),
+            "installed": len(installed),
+            "categories": len(set(p.category for p in plugins)),
+            "last_update": datetime.fromtimestamp(self._last_update).isoformat() if self._last_update else None,
+        }
+
+    # ══════════════════════════════════════════════════════════════════════════
+    # MÉTODOS PRIVADOS
+    # ══════════════════════════════════════════════════════════════════════════
+
+    def _fetch_remote(self) -> List[PluginInfo]:
+        """Obtiene registry del servidor remoto."""
+        req = urllib.request.Request(
+            self.REGISTRY_URL,
+            headers={"User-Agent": "HanusCode/1.0"}
+        )
+
+        with urllib.request.urlopen(req, timeout=10) as response:
+            data = json.loads(response.read().decode("utf-8"))
+
+        plugins = []
+        for item in data.get("plugins", []):
+            plugins.append(PluginInfo(
+                name=item["name"],
+                display_name=item.get("display_name", item["name"]),
+                description=item.get("description", ""),
+                author=item.get("author", "unknown"),
+                version=item.get("version", "1.0.0"),
+                repository=item.get("repository", ""),
+                download_url=item.get("download_url", ""),
+                category=item.get("category", "general"),
+                tags=item.get("tags", []),
+                stars=item.get("stars", 0),
+                updated=item.get("updated", ""),
+            ))
+
+        return plugins
+
+    def _download(self, url: str) -> str:
+        """Descarga contenido de una URL."""
+        req = urllib.request.Request(url, headers={"User-Agent": "HanusCode/1.0"})
+        with urllib.request.urlopen(req, timeout=30) as response:
+            return response.read().decode("utf-8")
+
+    def _update_cache(self, plugins: List[PluginInfo]) -> None:
+        """Actualiza el cache."""
+        self._cache = {p.name: p for p in plugins}
+        self._last_update = time.time()
+
+        # Guardar a disco
+        try:
+            data = {
+                "plugins": [p.to_dict() for p in plugins],
+                "timestamp": self._last_update,
+            }
+            self._cache_file.write_text(json.dumps(data, indent=2), encoding="utf-8")
+        except Exception:
+            pass
+
+    def _load_cache(self) -> bool:
+        """Carga cache desde disco."""
+        if not self._cache_file.exists():
+            return False
+
+        try:
+            data = json.loads(self._cache_file.read_text(encoding="utf-8"))
+            self._last_update = data.get("timestamp", 0)
+
+            for item in data.get("plugins", []):
+                self._cache[item["name"]] = PluginInfo(
+                    name=item["name"],
+                    display_name=item.get("display_name", item["name"]),
+                    description=item.get("description", ""),
+                    author=item.get("author", "unknown"),
+                    version=item.get("version", "1.0.0"),
+                    repository=item.get("repository", ""),
+                    download_url=item.get("download_url", ""),
+                    category=item.get("category", "general"),
+                    tags=item.get("tags", []),
+                )
+
+            return True
+        except Exception:
+            return False
+
+
+# Import typing Tuple
+from typing import Tuple
+
+# Instancia global
+_registry: Optional[PluginRegistry] = None
+
+
+def get_registry(plugins_dir: Path = None) -> PluginRegistry:
+    global _registry
+    if _registry is None or (plugins_dir and _registry.plugins_dir != plugins_dir):
+        _registry = PluginRegistry(plugins_dir or Path.cwd() / "plugins")
+    return _registry

hanus/plugins/__init__.py

@@ -0,0 +1 @@
+# plugins/__init__.py