janito 3.2.0__py3-none-any.whl → 3.3.0__py3-none-any.whl

janito/plugins_backup_20250825_070018/discovery.py

@@ -0,0 +1,289 @@
+"""
+Plugin discovery utilities.
+
+Plugins can be provided in several formats:
+
+1. Single Python file: A .py file containing a Plugin class
+   Example: plugins/my_plugin.py
+
+2. Python package directory: A directory with __init__.py or plugin.py
+   Example: plugins/my_plugin/__init__.py
+   Example: plugins/my_plugin/plugin.py
+
+3. Installed Python package: An installed package with a Plugin class
+   Example: pip install janito-plugin-example
+
+4. ZIP file: A .zip file containing a Python package structure
+   Example: plugins/my_plugin.zip (containing package structure)
+
+The plugin discovery system searches these locations in order:
+- Current working directory/plugins/
+- ~/.janito/plugins/
+- Python installation share/janito/plugins/
+- Any additional paths specified via configuration
+"""
+
+import os
+import sys
+import importlib
+import importlib.util
+from pathlib import Path
+from typing import Optional, List
+import logging
+
+from janito.plugin_system.base import Plugin
+from .builtin import load_builtin_plugin, BuiltinPluginRegistry
+from janito.plugin_system.core_loader import load_core_plugin
+
+logger = logging.getLogger(__name__)
+
+
+def discover_plugins(
+    plugin_name: str, search_paths: List[Path] = None
+) -> Optional[Plugin]:
+    """
+    Discover and load a plugin by name.
+
+    Supports multiple plugin formats:
+    - Single .py files
+    - Python package directories
+    - Package-based plugins (e.g., core.filemanager)
+    - Installed Python packages
+    - ZIP files containing packages
+
+    Args:
+        plugin_name: Name of the plugin to discover
+        search_paths: List of directories to search for plugins
+
+    Returns:
+        Plugin instance if found, None otherwise
+    """
+    if search_paths is None:
+        search_paths = []
+
+    # Add default search paths
+    default_paths = [
+        Path.cwd() / "plugins",
+        Path.home() / ".janito" / "plugins",
+        Path(sys.prefix) / "share" / "janito" / "plugins",
+    ]
+
+    all_paths = search_paths + default_paths
+
+    # Handle package-based plugins (e.g., core.filemanager)
+    if "." in plugin_name:
+        parts = plugin_name.split(".")
+        if len(parts) == 2:
+            package_name, submodule_name = parts
+
+            # Handle core plugins with dedicated loader
+            if plugin_name.startswith(("core.", "dev.", "ui.", "web.")):
+                plugin = load_core_plugin(plugin_name)
+                if plugin:
+                    return plugin
+
+            for base_path in all_paths:
+                package_path = base_path / package_name / submodule_name / "__init__.py"
+                if package_path.exists():
+                    return _load_plugin_from_file(package_path, plugin_name=plugin_name)
+
+                plugin_path = base_path / package_name / submodule_name / "plugin.py"
+                if plugin_path.exists():
+                    return _load_plugin_from_file(plugin_path, plugin_name=plugin_name)
+
+    # Try to find plugin in search paths
+    for base_path in all_paths:
+        plugin_path = base_path / plugin_name
+        if plugin_path.exists():
+            return _load_plugin_from_directory(plugin_path)
+
+        # Try as Python module
+        module_path = base_path / f"{plugin_name}.py"
+        if module_path.exists():
+            return _load_plugin_from_file(module_path)
+
+    # Check for builtin plugins
+    builtin_plugin = load_builtin_plugin(plugin_name)
+    if builtin_plugin:
+        return builtin_plugin
+
+    # Try importing as installed package
+    try:
+        return _load_plugin_from_package(plugin_name)
+    except ImportError:
+        pass
+
+    return None
+
+
+def _load_plugin_from_directory(plugin_path: Path) -> Optional[Plugin]:
+    """Load a plugin from a directory."""
+    try:
+        # Look for __init__.py or plugin.py
+        init_file = plugin_path / "__init__.py"
+        plugin_file = plugin_path / "plugin.py"
+
+        if init_file.exists():
+            return _load_plugin_from_file(init_file, plugin_name=plugin_path.name)
+        elif plugin_file.exists():
+            return _load_plugin_from_file(plugin_file, plugin_name=plugin_path.name)
+
+    except Exception as e:
+        logger.error(f"Failed to load plugin from directory {plugin_path}: {e}")
+
+    return None
+
+
+def _load_plugin_from_file(
+    file_path: Path, plugin_name: str = None
+) -> Optional[Plugin]:
+    """Load a plugin from a Python file."""
+    try:
+        if plugin_name is None:
+            plugin_name = file_path.stem
+
+        spec = importlib.util.spec_from_file_location(plugin_name, file_path)
+        if spec is None or spec.loader is None:
+            return None
+
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+
+        # Look for Plugin class
+        for attr_name in dir(module):
+            attr = getattr(module, attr_name)
+            if isinstance(attr, type) and issubclass(attr, Plugin) and attr != Plugin:
+                return attr()
+
+        # Check for package-based plugin with __plugin_name__ metadata
+        if hasattr(module, "__plugin_name__"):
+            from janito.plugin_system.base import PluginMetadata
+
+            # Create a dynamic plugin class
+            class PackagePlugin(Plugin):
+                def __init__(self):
+                    super().__init__()
+                    self._module = module
+
+                def get_metadata(self) -> PluginMetadata:
+                    return PluginMetadata(
+                        name=getattr(module, "__plugin_name__", plugin_name),
+                        version=getattr(module, "__plugin_version__", "1.0.0"),
+                        description=getattr(
+                            module,
+                            "__plugin_description__",
+                            f"Package plugin: {plugin_name}",
+                        ),
+                        author=getattr(module, "__plugin_author__", "Unknown"),
+                        license=getattr(module, "__plugin_license__", "MIT"),
+                    )
+
+                def get_tools(self):
+                    return getattr(module, "__plugin_tools__", [])
+
+                def initialize(self):
+                    if hasattr(module, "initialize"):
+                        module.initialize()
+
+                def cleanup(self):
+                    if hasattr(module, "cleanup"):
+                        module.cleanup()
+
+            return PackagePlugin()
+
+    except Exception as e:
+        logger.error(f"Failed to load plugin from file {file_path}: {e}")
+
+    return None
+
+
+def _load_plugin_from_package(package_name: str) -> Optional[Plugin]:
+    """Load a plugin from an installed package."""
+    try:
+        module = importlib.import_module(package_name)
+
+        # Look for Plugin class
+        for attr_name in dir(module):
+            attr = getattr(module, attr_name)
+            if isinstance(attr, type) and issubclass(attr, Plugin) and attr != Plugin:
+                return attr()
+
+    except ImportError as e:
+        logger.debug(f"Could not import package {package_name}: {e}")
+
+    return None
+
+
+def list_available_plugins(search_paths: List[Path] = None) -> List[str]:
+    """
+    List all available plugins in search paths.
+
+    Scans for plugins in multiple formats:
+    - .py files (excluding __init__.py)
+    - Directories with __init__.py or plugin.py
+    - Package directories with plugin metadata (__plugin_name__)
+    - Any valid plugin structure in search paths
+
+    Args:
+        search_paths: List of directories to search for plugins
+
+    Returns:
+        List of plugin names found
+    """
+    if search_paths is None:
+        search_paths = []
+
+    # Add default search paths
+    default_paths = [
+        Path.cwd() / "plugins",
+        Path.home() / ".janito" / "plugins",
+        Path(sys.prefix) / "share" / "janito" / "plugins",
+    ]
+
+    all_paths = search_paths + default_paths
+    plugins = []
+
+    for base_path in all_paths:
+        if not base_path.exists():
+            continue
+
+        # Look for directories with __init__.py or plugin.py
+        for item in base_path.iterdir():
+            if item.is_dir():
+                # Check for package-based plugins (subdirectories with __init__.py)
+                if (item / "__init__.py").exists():
+                    # Check subdirectories for plugin metadata
+                    for subitem in item.iterdir():
+                        if subitem.is_dir() and (subitem / "__init__.py").exists():
+                            try:
+                                import importlib.util
+
+                                spec = importlib.util.spec_from_file_location(
+                                    f"{item.name}.{subitem.name}",
+                                    subitem / "__init__.py",
+                                )
+                                if spec and spec.loader:
+                                    module = importlib.util.module_from_spec(spec)
+                                    spec.loader.exec_module(module)
+
+                                    # Check for plugin metadata
+                                    if hasattr(module, "__plugin_name__"):
+                                        plugins.append(
+                                            getattr(module, "__plugin_name__")
+                                        )
+                            except Exception:
+                                pass
+
+                # Also check for plugin.py files
+                plugin_file = item / "plugin.py"
+                if plugin_file.exists():
+                    plugins.append(item.name)
+
+            elif item.suffix == ".py" and item.stem != "__init__":
+                plugins.append(item.stem)
+
+    # Add builtin plugins
+    builtin_plugins = BuiltinPluginRegistry.list_builtin_plugins()
+    plugins.extend(builtin_plugins)
+
+    return sorted(set(plugins))

janito/{plugins → plugins_backup_20250825_070018}/discovery_core.py

@@ -17,11 +17,11 @@ from .core_adapter import CorePluginAdapter
 def _load_core_plugin(package_path: Path, plugin_name: str) -> Optional[Plugin]:
     """
     Load a core plugin from a package directory.
-
+    
     Args:
         package_path: Path to the __init__.py file
         plugin_name: Full plugin name (e.g., core.filemanager)
-
+        
     Returns:
         Plugin instance if loaded successfully
     """
@@ -30,25 +30,20 @@ def _load_core_plugin(package_path: Path, plugin_name: str) -> Optional[Plugin]:
         spec = importlib.util.spec_from_file_location(plugin_name, package_path)
         if spec is None or spec.loader is None:
             return None
-
+            
         module = importlib.util.module_from_spec(spec)
         spec.loader.exec_module(module)
-
+        
         # Get plugin metadata
         plugin_name_attr = getattr(module, "__plugin_name__", plugin_name)
-        description = getattr(
-            module, "__plugin_description__", f"Core plugin: {plugin_name}"
-        )
-
+        description = getattr(module, "__plugin_description__", f"Core plugin: {plugin_name}")
+        
         # Create and return the core plugin adapter
         plugin = CorePluginAdapter(plugin_name_attr, description, module)
         plugin.initialize()  # Initialize to set up tools
         return plugin
-
+        
     except Exception as e:
         import logging
-
-        logging.getLogger(__name__).error(
-            f"Failed to load core plugin {plugin_name}: {e}"
-        )
-        return None
+        logging.getLogger(__name__).error(f"Failed to load core plugin {plugin_name}: {e}")
+        return None

janito/plugins_backup_20250825_070018/example_plugin.py

@@ -0,0 +1,108 @@
+"""
+Example plugin demonstrating the plugin system.
+"""
+
+from janito.plugin_system.base import Plugin, PluginMetadata, PluginResource
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from typing import Dict, Any
+
+
+class HelloWorldTool(ToolBase):
+    """A simple tool that says hello."""
+
+    tool_name = "hello_world"
+    permissions = ToolPermissions(read=True, write=False, execute=True)
+
+    def run(self, name: str = "World") -> str:
+        """
+        Say hello to someone.
+
+        Args:
+            name: Name of the person to greet
+
+        Returns:
+            Greeting message
+        """
+        self.report_action(f"Saying hello to {name}", "greet")
+        return f"Hello, {name}!"
+
+
+class CalculatorTool(ToolBase):
+    """A simple calculator tool."""
+
+    tool_name = "calculator"
+    permissions = ToolPermissions(read=True, write=False, execute=True)
+
+    def run(self, operation: str, a: float, b: float) -> str:
+        """
+        Perform basic calculations.
+
+        Args:
+            operation: Operation to perform (add, subtract, multiply, divide)
+            a: First number
+            b: Second number
+
+        Returns:
+            Result as string
+        """
+        self.report_action(f"Calculating {a} {operation} {b}", "calculate")
+
+        if operation == "add":
+            result = a + b
+        elif operation == "subtract":
+            result = a - b
+        elif operation == "multiply":
+            result = a * b
+        elif operation == "divide":
+            if b == 0:
+                return "Error: Division by zero"
+            result = a / b
+        else:
+            return f"Error: Unknown operation '{operation}'"
+
+        return str(result)
+
+
+class ExamplePlugin(Plugin):
+    """Example plugin providing basic tools."""
+
+    def get_metadata(self) -> PluginMetadata:
+        return PluginMetadata(
+            name="example",
+            version="1.0.0",
+            description="Example plugin with basic tools",
+            author="Janito Team",
+            license="MIT",
+            homepage="https://github.com/janito/example-plugin",
+        )
+
+    def get_tools(self):
+        return [HelloWorldTool, CalculatorTool]
+
+    def initialize(self):
+        print("Example plugin initialized!")
+
+    def cleanup(self):
+        print("Example plugin cleaned up!")
+
+    def get_config_schema(self) -> Dict[str, Any]:
+        """Return JSON schema for plugin configuration."""
+        return {
+            "type": "object",
+            "properties": {
+                "greeting_prefix": {
+                    "type": "string",
+                    "description": "Custom greeting prefix for hello_world tool",
+                    "default": "Hello",
+                },
+                "max_calculation": {
+                    "type": "number",
+                    "description": "Maximum allowed calculation result",
+                    "default": 1000000,
+                },
+            },
+        }
+
+
+# This makes the plugin discoverable
+PLUGIN_CLASS = ExamplePlugin

janito/plugins_backup_20250825_070018/manager.py

@@ -0,0 +1,243 @@
+"""
+Plugin manager for loading and managing plugins.
+"""
+
+import os
+import sys
+import importlib
+import importlib.util
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+import logging
+
+from janito.plugin_system.base import Plugin, PluginMetadata
+from .discovery import discover_plugins
+from .config import load_plugins_config, get_user_plugins_dir
+from .builtin import BuiltinPluginRegistry, load_builtin_plugin
+from janito.tools.adapters.local import LocalToolsAdapter
+
+logger = logging.getLogger(__name__)
+
+
+class PluginManager:
+    """
+    Manages plugin loading, registration, and lifecycle.
+    """
+
+    def __init__(self, tools_adapter: Optional[LocalToolsAdapter] = None):
+        self.tools_adapter = tools_adapter or LocalToolsAdapter()
+        self.plugins: Dict[str, Plugin] = {}
+        self.plugin_configs: Dict[str, Dict[str, Any]] = {}
+        self.plugin_paths: List[Path] = []
+
+    def add_plugin_path(self, path: str) -> None:
+        """Add a directory to search for plugins."""
+        plugin_path = Path(path)
+        if plugin_path.exists() and plugin_path.is_dir():
+            self.plugin_paths.append(plugin_path)
+            if str(plugin_path) not in sys.path:
+                sys.path.insert(0, str(plugin_path))
+
+    def load_plugin(
+        self, plugin_name: str, config: Optional[Dict[str, Any]] = None
+    ) -> bool:
+        """
+        Load a plugin by name.
+
+        Args:
+            plugin_name: Name of the plugin to load
+            config: Optional configuration for the plugin
+
+        Returns:
+            True if plugin loaded successfully
+        """
+        try:
+            if plugin_name in self.plugins:
+                logger.warning(f"Plugin {plugin_name} already loaded")
+                return True
+
+            plugin = discover_plugins(plugin_name, self.plugin_paths)
+            if not plugin:
+                logger.error(f"Plugin {plugin_name} not found")
+                return False
+
+            # Store config
+            if config:
+                self.plugin_configs[plugin_name] = config
+
+            # Validate config if provided
+            if config and hasattr(plugin, "validate_config"):
+                if not plugin.validate_config(config):
+                    logger.error(f"Invalid configuration for plugin {plugin_name}")
+                    return False
+
+            # Initialize plugin
+            plugin.initialize()
+
+            # Register tools
+            tools = plugin.get_tools()
+            for tool_class in tools:
+                self.tools_adapter.register_tool(tool_class)
+
+            # Store plugin
+            self.plugins[plugin_name] = plugin
+
+            logger.info(f"Successfully loaded plugin: {plugin_name}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to load plugin {plugin_name}: {e}")
+            return False
+
+    def unload_plugin(self, plugin_name: str) -> bool:
+        """
+        Unload a plugin.
+
+        Args:
+            plugin_name: Name of the plugin to unload
+
+        Returns:
+            True if plugin unloaded successfully
+        """
+        try:
+            if plugin_name not in self.plugins:
+                logger.warning(f"Plugin {plugin_name} not loaded")
+                return False
+
+            plugin = self.plugins[plugin_name]
+
+            # Unregister tools
+            tools = plugin.get_tools()
+            for tool_class in tools:
+                tool_name = getattr(tool_class(), "tool_name", None)
+                if tool_name:
+                    self.tools_adapter.unregister_tool(tool_name)
+
+            # Cleanup plugin
+            plugin.cleanup()
+
+            # Remove from registry
+            del self.plugins[plugin_name]
+            if plugin_name in self.plugin_configs:
+                del self.plugin_configs[plugin_name]
+
+            logger.info(f"Successfully unloaded plugin: {plugin_name}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to unload plugin {plugin_name}: {e}")
+            return False
+
+    def list_plugins(self) -> List[str]:
+        """Return list of loaded plugin names."""
+        return list(self.plugins.keys())
+
+    def get_plugin(self, plugin_name: str) -> Optional[Plugin]:
+        """Get a loaded plugin by name."""
+        return self.plugins.get(plugin_name)
+
+    def get_plugin_metadata(self, plugin_name: str) -> Optional[PluginMetadata]:
+        """Get metadata for a loaded plugin."""
+        plugin = self.plugins.get(plugin_name)
+        return plugin.metadata if plugin else None
+
+    def load_plugins_from_config(self, config: Dict[str, Any]) -> None:
+        """
+        Load plugins from configuration.
+
+        Args:
+            config: Configuration dict with plugin settings
+        """
+        plugins_config = config.get("plugins", {})
+
+        # Add plugin paths
+        for path in plugins_config.get("paths", []):
+            self.add_plugin_path(path)
+
+        # Load plugins
+        for plugin_name, plugin_config in plugins_config.get("load", {}).items():
+            if isinstance(plugin_config, bool):
+                if plugin_config:
+                    self.load_plugin(plugin_name)
+            else:
+                self.load_plugin(plugin_name, plugin_config)
+
+    def load_plugins_from_user_config(self) -> None:
+        """
+        Load plugins from user configuration directory.
+        Uses ~/.janito/plugins.json instead of janito.json
+        """
+        config = load_plugins_config()
+        self.load_plugins_from_config(config)
+
+    def reload_plugin(self, plugin_name: str) -> bool:
+        """
+        Reload a plugin.
+
+        Args:
+            plugin_name: Name of the plugin to reload
+
+        Returns:
+            True if plugin reloaded successfully
+        """
+        config = self.plugin_configs.get(plugin_name)
+        self.unload_plugin(plugin_name)
+        return self.load_plugin(plugin_name, config)
+
+    def get_loaded_plugins_info(self) -> Dict[str, Dict[str, Any]]:
+        """Get information about all loaded plugins."""
+        info = {}
+        for name, plugin in self.plugins.items():
+            info[name] = {
+                "metadata": plugin.metadata,
+                "tools": [tool.__name__ for tool in plugin.get_tools()],
+                "commands": list(plugin.get_commands().keys()),
+                "config": self.plugin_configs.get(name, {}),
+                "builtin": BuiltinPluginRegistry.is_builtin(name),
+                "resources": [
+                    {
+                        "name": resource.name,
+                        "type": resource.type,
+                        "description": resource.description,
+                        "schema": resource.schema,
+                    }
+                    for resource in plugin.get_resources()
+                ],
+            }
+        return info
+
+    def get_plugin_resources(self, plugin_name: str) -> List[Dict[str, Any]]:
+        """
+        Get resources provided by a specific plugin.
+
+        Args:
+            plugin_name: Name of the plugin
+
+        Returns:
+            List of resource dictionaries
+        """
+        plugin = self.plugins.get(plugin_name)
+        if not plugin:
+            return []
+
+        return [
+            {
+                "name": resource.name,
+                "type": resource.type,
+                "description": resource.description,
+                "schema": resource.schema,
+            }
+            for resource in plugin.get_resources()
+        ]
+
+    def list_all_resources(self) -> Dict[str, List[Dict[str, Any]]]:
+        """
+        List all resources from all loaded plugins.
+
+        Returns:
+            Dict mapping plugin names to their resources
+        """
+        all_resources = {}
+        for plugin_name in self.plugins:
+            all_resources[plugin_name] = self.get_plugin_resources(plugin_name)
+        return all_resources