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

janito/plugins_backup_20250825_070018/discovery.py

@@ -1,289 +0,0 @@
-"""
-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_backup_20250825_070018/example_plugin.py

@@ -1,108 +0,0 @@
-"""
-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

@@ -1,243 +0,0 @@
-"""
-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

janito/plugins_backup_20250825_070018/tools/__init__.py

@@ -1,10 +0,0 @@
-"""
-Core tools plugin for janito.
-
-This plugin provides the essential tools for file operations, code execution,
-and system interactions that are core to janito's functionality.
-"""
-
-from .core_tools_plugin import CoreToolsPlugin
-
-__all__ = ["CoreToolsPlugin"]