crackerjack 0.18.2__py3-none-any.whl → 0.45.2__py3-none-any.whl

crackerjack/plugins/loader.py

@@ -0,0 +1,335 @@
+import importlib
+import importlib.util
+import json
+import logging
+import typing as t
+from pathlib import Path
+
+from crackerjack.config.hooks import HookStage
+
+from .base import (
+    PluginBase,
+    PluginMetadata,
+    PluginRegistry,
+    PluginType,
+    get_plugin_registry,
+)
+from .hooks import CustomHookDefinition, CustomHookPlugin
+
+
+class PluginLoadError(Exception):
+    pass
+
+
+class PluginLoader:
+    def __init__(self, registry: PluginRegistry | None = None) -> None:
+        self.registry = registry or get_plugin_registry()
+        self.logger = logging.getLogger("crackerjack.plugin_loader")
+
+    def load_plugin_from_file(self, plugin_file: Path) -> PluginBase:
+        if not plugin_file.exists():
+            msg = f"Plugin file not found: {plugin_file}"
+            raise PluginLoadError(msg)
+
+        if plugin_file.suffix != ".py":
+            msg = f"Plugin file must be .py: {plugin_file}"
+            raise PluginLoadError(msg)
+
+        spec = importlib.util.spec_from_file_location(plugin_file.stem, plugin_file)
+        if not spec or not spec.loader:
+            msg = f"Could not create module spec for: {plugin_file}"
+            raise PluginLoadError(msg)
+
+        module = importlib.util.module_from_spec(spec)
+
+        try:
+            spec.loader.exec_module(module)
+        except Exception as e:
+            msg = f"Failed to execute plugin module {plugin_file}: {e}"
+            raise PluginLoadError(msg)
+
+        plugin = self._extract_plugin_from_module(module, plugin_file)
+
+        if not isinstance(plugin, PluginBase):
+            msg = f"Plugin {plugin_file} does not provide a PluginBase instance"
+            raise PluginLoadError(
+                msg,
+            )
+
+        return plugin
+
+    def load_plugin_from_config(self, config_file: Path) -> PluginBase:
+        if not config_file.exists():
+            msg = f"Plugin config file not found: {config_file}"
+            raise PluginLoadError(msg)
+
+        try:
+            if config_file.suffix == ".json":
+                with config_file.open() as f:
+                    config = json.load(f)
+            elif config_file.suffix in (".yaml", ".yml"):
+                import yaml
+
+                with config_file.open() as f:
+                    config = yaml.safe_load(f)
+            else:
+                msg = f"Unsupported config format: {config_file.suffix}"
+                raise PluginLoadError(
+                    msg,
+                )
+        except Exception as e:
+            msg = f"Failed to parse config file {config_file}: {e}"
+            raise PluginLoadError(msg)
+
+        return self._create_plugin_from_config(config, config_file)
+
+    def _extract_plugin_from_module(
+        self,
+        module: t.Any,
+        plugin_file: Path,
+    ) -> PluginBase:
+        plugin = self._try_standard_entry_points(module)
+        if plugin:
+            return plugin
+
+        plugin = self._try_plugin_subclasses(module, plugin_file)
+        if plugin:
+            return plugin
+
+        msg = f"No valid plugin found in {plugin_file}"
+        raise PluginLoadError(msg)
+
+    def _try_standard_entry_points(self, module: t.Any) -> PluginBase | None:
+        entry_points = [
+            "plugin",
+            "create_plugin",
+            "PLUGIN",
+        ]
+
+        for entry_point in entry_points:
+            plugin = self._try_single_entry_point(module, entry_point)
+            if plugin:
+                return plugin
+
+        return None
+
+    def _try_single_entry_point(
+        self,
+        module: t.Any,
+        entry_point: str,
+    ) -> PluginBase | None:
+        if not hasattr(module, entry_point):
+            return None
+
+        obj = getattr(module, entry_point)
+
+        if isinstance(obj, PluginBase):
+            return obj
+        if callable(obj):
+            return self._try_factory_function(obj, entry_point)
+
+        return None
+
+    def _try_factory_function(
+        self,
+        factory: t.Callable[..., t.Any],
+        name: str,
+    ) -> PluginBase | None:
+        try:
+            result = factory()
+            if isinstance(result, PluginBase):
+                return result
+        except Exception as e:
+            self.logger.warning(f"Plugin factory {name} failed: {e}")
+        return None
+
+    def _try_plugin_subclasses(
+        self,
+        module: t.Any,
+        plugin_file: Path,
+    ) -> PluginBase | None:
+        for name, obj in vars(module).items():
+            if self._is_valid_plugin_class(obj):
+                plugin = self._try_instantiate_plugin_class(obj, name, plugin_file)
+                if plugin:
+                    return plugin
+        return None
+
+    def _is_valid_plugin_class(self, obj: t.Any) -> bool:
+        return (
+            isinstance(obj, type)
+            and issubclass(obj, PluginBase)
+            and obj is not PluginBase
+        )
+
+    def _try_instantiate_plugin_class(
+        self,
+        plugin_class: type[PluginBase],
+        name: str,
+        plugin_file: Path,
+    ) -> PluginBase | None:
+        try:
+            metadata = PluginMetadata(
+                name=plugin_file.stem,
+                version="1.0.0",
+                plugin_type=PluginType.HOOK,
+                description="Custom plugin",
+            )
+            return plugin_class(metadata)
+        except Exception as e:
+            self.logger.warning(f"Failed to instantiate plugin class {name}: {e}")
+            return None
+
+    def _create_plugin_from_config(
+        self,
+        config: dict[str, t.Any],
+        config_file: Path,
+    ) -> PluginBase:
+        metadata = PluginMetadata(
+            name=config.get("name", config_file.stem),
+            version=config.get("version", "1.0.0"),
+            plugin_type=PluginType(config.get("type", "hook")),
+            description=config.get("description", "Custom plugin"),
+            author=config.get("author", ""),
+            license=config.get("license", ""),
+            dependencies=config.get("dependencies", []),
+        )
+
+        if metadata.plugin_type == PluginType.HOOK:
+            return self._create_hook_plugin_from_config(metadata, config)
+        msg = f"Unsupported plugin type: {metadata.plugin_type}"
+        raise PluginLoadError(msg)
+
+    def _create_hook_plugin_from_config(
+        self,
+        metadata: PluginMetadata,
+        config: dict[str, t.Any],
+    ) -> CustomHookPlugin:
+        hooks_config = config.get("hooks", [])
+        hook_definitions = []
+
+        for hook_config in hooks_config:
+            hook_def = CustomHookDefinition(
+                name=hook_config["name"],
+                description=hook_config.get("description", ""),
+                command=hook_config.get("command", []),
+                file_patterns=hook_config.get("file_patterns", []),
+                timeout=hook_config.get("timeout", 60),
+                stage=HookStage(hook_config.get("stage", "comprehensive")),
+                requires_files=hook_config.get("requires_files", True),
+                parallel_safe=hook_config.get("parallel_safe", True),
+            )
+            hook_definitions.append(hook_def)
+
+        return CustomHookPlugin(metadata, hook_definitions)
+
+    def load_and_register(self, plugin_source: Path) -> bool:
+        try:
+            if plugin_source.suffix == ".py":
+                plugin = self.load_plugin_from_file(plugin_source)
+            elif plugin_source.suffix in (".json", ".yaml", ".yml"):
+                plugin = self.load_plugin_from_config(plugin_source)
+            else:
+                self.logger.error(f"Unsupported plugin file type: {plugin_source}")
+                return False
+
+            success = self.registry.register(plugin)
+            if success:
+                self.logger.info(f"Successfully loaded plugin: {plugin.name}")
+            else:
+                self.logger.warning(f"Plugin already registered: {plugin.name}")
+
+            return success
+
+        except PluginLoadError as e:
+            self.logger.exception(f"Failed to load plugin from {plugin_source}: {e}")
+            return False
+        except Exception as e:
+            self.logger.exception(
+                f"Unexpected error loading plugin {plugin_source}: {e}"
+            )
+            return False
+
+
+class PluginDiscovery:
+    def __init__(self, loader: PluginLoader | None = None) -> None:
+        self.loader = loader or PluginLoader()
+        self.logger = logging.getLogger("crackerjack.plugin_discovery")
+
+    def discover_in_directory(
+        self,
+        directory: Path,
+        recursive: bool = False,
+    ) -> list[Path]:
+        if not directory.exists() or not directory.is_dir():
+            return []
+
+        plugin_files: list[Path] = []
+
+        patterns = ["*.py", "*.json", "*.yaml", "*.yml"]
+
+        for pattern in patterns:
+            if recursive:
+                plugin_files.extend(directory.rglob(pattern))
+            else:
+                plugin_files.extend(directory.glob(pattern))
+
+        return [f for f in plugin_files if self._looks_like_plugin_file(f)]
+
+    def discover_in_project(self, project_path: Path) -> list[Path]:
+        plugin_files: list[Path] = []
+
+        plugin_dirs = [
+            project_path / "plugins",
+            project_path / ".cache" / "crackerjack" / "plugins",
+            project_path / "tools" / "crackerjack",
+        ]
+
+        for plugin_dir in plugin_dirs:
+            if plugin_dir.exists():
+                plugin_files.extend(
+                    self.discover_in_directory(plugin_dir, recursive=True),
+                )
+
+        return plugin_files
+
+    def load_discovered_plugins(self, plugin_files: list[Path]) -> dict[str, bool]:
+        results = {}
+
+        for plugin_file in plugin_files:
+            self.logger.info(f"Loading plugin: {plugin_file}")
+            success = self.loader.load_and_register(plugin_file)
+            results[str(plugin_file)] = success
+
+        return results
+
+    def auto_discover_and_load(self, project_path: Path) -> dict[str, bool]:
+        plugin_files = self.discover_in_project(project_path)
+
+        if plugin_files:
+            self.logger.info(f"Found {len(plugin_files)} potential plugin files")
+            return self.load_discovered_plugins(plugin_files)
+        self.logger.info("No plugin files found")
+        return {}
+
+    def _looks_like_plugin_file(self, file_path: Path) -> bool:
+        name_lower = file_path.name.lower()
+
+        if name_lower.startswith(("test_", "__", ".")):
+            return False
+
+        if name_lower in ("__init__.py", "setup.py", "conftest.py"):
+            return False
+
+        plugin_indicators = [
+            "plugin",
+            "hook",
+            "extension",
+            "addon",
+            "crackerjack",
+            "check",
+            "lint",
+            "format",
+        ]
+
+        return any(indicator in name_lower for indicator in plugin_indicators)

crackerjack/plugins/managers.py

@@ -0,0 +1,264 @@
+import logging
+import typing as t
+from pathlib import Path
+
+from acb.console import Console
+
+from crackerjack.models.protocols import OptionsProtocol
+
+from .base import PluginRegistry, PluginType, get_plugin_registry
+from .hooks import HookPluginBase, HookPluginRegistry, get_hook_plugin_registry
+from .loader import PluginDiscovery, PluginLoader
+
+
+class PluginManager:
+    def __init__(
+        self,
+        console: Console,
+        project_path: Path,
+        registry: PluginRegistry | None = None,
+        hook_registry: HookPluginRegistry | None = None,
+    ) -> None:
+        self.console = console
+        self.project_path = project_path
+        self.registry = registry or get_plugin_registry()
+        self.hook_registry = hook_registry or get_hook_plugin_registry()
+
+        self.loader = PluginLoader(self.registry)
+        self.discovery = PluginDiscovery(self.loader)
+        self.logger = logging.getLogger("crackerjack.plugin_manager")
+
+        self._initialized = False
+
+    def initialize(self) -> bool:
+        if self._initialized:
+            return True
+
+        self.logger.info("Initializing plugin system")
+
+        try:
+            results = self.discovery.auto_discover_and_load(self.project_path)
+
+            loaded_count = sum(1 for success in results.values() if success)
+            total_count = len(results)
+
+            if total_count > 0:
+                self.console.print(
+                    f"[green]✅[/ green] Loaded {loaded_count} / {total_count} plugins",
+                )
+
+            activation_results = self.registry.activate_all()
+            activated_count = sum(
+                1 for success in activation_results.values() if success
+            )
+
+            if activated_count > 0:
+                self.console.print(
+                    f"[green]✅[/ green] Activated {activated_count} plugins",
+                )
+
+            hook_plugins = self.registry.get_enabled(PluginType.HOOK)
+            for plugin in hook_plugins:
+                if isinstance(plugin, HookPluginBase):
+                    if hasattr(plugin, "initialize"):
+                        plugin.initialize(self.console, self.project_path)
+                    self.hook_registry.register_hook_plugin(plugin)
+
+            self._initialized = True
+            return True
+
+        except Exception as e:
+            self.logger.exception(f"Failed to initialize plugin system: {e}")
+            self.console.print(
+                f"[red]❌[/ red] Plugin system initialization failed: {e}",
+            )
+            return False
+
+    def shutdown(self) -> None:
+        if not self._initialized:
+            return
+
+        self.logger.info("Shutting down plugin system")
+
+        try:
+            results = self.registry.deactivate_all()
+            deactivated_count = sum(1 for success in results.values() if success)
+
+            if deactivated_count > 0:
+                self.console.print(
+                    f"[yellow]⏹️[/ yellow] Deactivated {deactivated_count} plugins",
+                )
+
+            self._initialized = False
+
+        except Exception as e:
+            self.logger.exception(f"Error during plugin system shutdown: {e}")
+
+    def list_plugins(self, plugin_type: PluginType | None = None) -> dict[str, t.Any]:
+        if plugin_type:
+            plugins = self.registry.get_by_type(plugin_type)
+        else:
+            plugins = list[t.Any](self.registry.list_all().values())
+
+        plugin_info = []
+        for plugin in plugins:
+            info = plugin.get_info()
+            info["active"] = plugin.enabled
+            plugin_info.append(info)
+
+        return {
+            "plugins": plugin_info,
+            "total": len(plugin_info),
+            "enabled": len([p for p in plugins if p.enabled]),
+        }
+
+    def get_plugin_stats(self) -> dict[str, t.Any]:
+        stats = self.registry.get_stats()
+
+        hook_plugins = self.registry.get_enabled(PluginType.HOOK)
+        custom_hooks = self.hook_registry.get_all_custom_hooks()
+
+        stats["hook_plugins"] = {
+            "active_plugins": len(hook_plugins),
+            "total_custom_hooks": len(custom_hooks),
+            "hook_names": list[t.Any](custom_hooks.keys()),
+        }
+
+        return stats
+
+    def enable_plugin(self, plugin_name: str) -> bool:
+        plugin = self.registry.get(plugin_name)
+        if not plugin:
+            self.console.print(f"[red]❌[/ red] Plugin not found: {plugin_name}")
+            return False
+
+        if plugin.enabled:
+            self.console.print(
+                f"[yellow]⚠️[/ yellow] Plugin already enabled: {plugin_name}",
+            )
+            return True
+
+        try:
+            plugin.enable()
+            success = plugin.activate()
+
+            if success:
+                self.console.print(f"[green]✅[/ green] Enabled plugin: {plugin_name}")
+
+                if plugin.plugin_type == PluginType.HOOK and isinstance(
+                    plugin, HookPluginBase
+                ):
+                    self.hook_registry.register_hook_plugin(plugin)
+
+                return True
+            plugin.disable()
+            self.console.print(
+                f"[red]❌[/ red] Failed to activate plugin: {plugin_name}",
+            )
+            return False
+
+        except Exception as e:
+            self.console.print(
+                f"[red]❌[/ red] Error enabling plugin {plugin_name}: {e}",
+            )
+            return False
+
+    def disable_plugin(self, plugin_name: str) -> bool:
+        plugin = self.registry.get(plugin_name)
+        if not plugin:
+            self.console.print(f"[red]❌[/ red] Plugin not found: {plugin_name}")
+            return False
+
+        if not plugin.enabled:
+            self.console.print(
+                f"[yellow]⚠️[/ yellow] Plugin already disabled: {plugin_name}",
+            )
+            return True
+
+        try:
+            success = plugin.deactivate()
+            plugin.disable()
+
+            if plugin.plugin_type == PluginType.HOOK:
+                self.hook_registry.unregister_hook_plugin(plugin_name)
+
+            if success:
+                self.console.print(
+                    f"[yellow]⏹️[/ yellow] Disabled plugin: {plugin_name}"
+                )
+            else:
+                self.console.print(
+                    f"[yellow]⚠️[/ yellow] Plugin disabled with warnings: {plugin_name}",
+                )
+
+            return True
+
+        except Exception as e:
+            self.console.print(
+                f"[red]❌[/ red] Error disabling plugin {plugin_name}: {e}",
+            )
+            return False
+
+    def reload_plugin(self, plugin_name: str) -> bool:
+        if not self.disable_plugin(plugin_name):
+            return False
+
+        return self.enable_plugin(plugin_name)
+
+    def configure_plugin(self, plugin_name: str, config: dict[str, t.Any]) -> bool:
+        plugin = self.registry.get(plugin_name)
+        if not plugin:
+            self.console.print(f"[red]❌[/ red] Plugin not found: {plugin_name}")
+            return False
+
+        try:
+            plugin.configure(config)
+            self.console.print(f"[green]✅[/ green] Configured plugin: {plugin_name}")
+            return True
+        except Exception as e:
+            self.console.print(
+                f"[red]❌[/ red] Error configuring plugin {plugin_name}: {e}",
+            )
+            return False
+
+    def install_plugin_from_file(self, plugin_file: Path) -> bool:
+        try:
+            success = self.loader.load_and_register(plugin_file)
+
+            if success:
+                self.console.print(
+                    f"[green]✅[/ green] Installed plugin from: {plugin_file}",
+                )
+
+                if self._initialized:
+                    plugins = self.registry.list_all()
+                    if plugins:
+                        latest_plugin_name = max(
+                            plugins.keys(),
+                            key=lambda k: id(plugins[k]),
+                        )
+                        self.enable_plugin(latest_plugin_name)
+            else:
+                self.console.print(
+                    f"[red]❌[/ red] Failed to install plugin from: {plugin_file}",
+                )
+
+            return success
+
+        except Exception as e:
+            self.console.print(
+                f"[red]❌[/ red] Error installing plugin {plugin_file}: {e}",
+            )
+            return False
+
+    def get_available_custom_hooks(self) -> list[str]:
+        custom_hooks = self.hook_registry.get_all_custom_hooks()
+        return list[t.Any](custom_hooks.keys())
+
+    def execute_custom_hook(
+        self,
+        hook_name: str,
+        files: list[Path],
+        options: OptionsProtocol,
+    ) -> t.Any:
+        return self.hook_registry.execute_custom_hook(hook_name, files, options)