janito 2.27.0__py3-none-any.whl → 2.28.0__py3-none-any.whl

janito/plugins/config.py

@@ -21,35 +21,32 @@ def get_plugins_config_path() -> Path:
 def load_plugins_config() -> Dict[str, Any]:
     """
     Load plugins configuration from user directory.
-    
+
     Returns:
         Dict containing plugins configuration
     """
     config_path = get_plugins_config_path()
-    
+
     if not config_path.exists():
         # Create default config if it doesn't exist
         default_config = {
             "plugins": {
-                "paths": [
-                    str(Path.home() / ".janito" / "plugins"),
-                    "./plugins"
-                ],
-                "load": {}
+                "paths": [str(Path.home() / ".janito" / "plugins"), "./plugins"],
+                "load": {},
             }
         }
-        
+
         # Ensure directory exists
         config_path.parent.mkdir(parents=True, exist_ok=True)
-        
+
         # Save default config
-        with open(config_path, 'w') as f:
+        with open(config_path, "w") as f:
             json.dump(default_config, f, indent=2)
-        
+
         return default_config
-    
+
     try:
-        with open(config_path, 'r') as f:
+        with open(config_path, "r") as f:
             return json.load(f)
     except (json.JSONDecodeError, IOError) as e:
         print(f"Warning: Failed to load plugins config from {config_path}: {e}")
@@ -59,20 +56,20 @@ def load_plugins_config() -> Dict[str, Any]:
 def save_plugins_config(config: Dict[str, Any]) -> bool:
     """
     Save plugins configuration to user directory.
-    
+
     Args:
         config: Configuration dict to save
-        
+
     Returns:
         True if saved successfully
     """
     config_path = get_plugins_config_path()
-    
+
     try:
         # Ensure directory exists
         config_path.parent.mkdir(parents=True, exist_ok=True)
-        
-        with open(config_path, 'w') as f:
+
+        with open(config_path, "w") as f:
             json.dump(config, f, indent=2)
         return True
     except IOError as e:
@@ -84,4 +81,4 @@ def get_user_plugins_dir() -> Path:
     """Get the user plugins directory."""
     plugins_dir = get_user_config_dir() / "plugins"
     plugins_dir.mkdir(parents=True, exist_ok=True)
-    return plugins_dir
+    return plugins_dir

janito/plugins/discovery.py

@@ -32,56 +32,79 @@ from typing import Optional, List
 import logging
 
 from .base import Plugin
+from .builtin import load_builtin_plugin, BuiltinPluginRegistry
 
 logger = logging.getLogger(__name__)
 
 
-def discover_plugins(plugin_name: str, search_paths: List[Path] = None) -> Optional[Plugin]:
+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
+            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
 
 
@@ -91,42 +114,78 @@ def _load_plugin_from_directory(plugin_path: Path) -> Optional[Plugin]:
         # 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]:
+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):
+            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.plugins.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
 
 
@@ -134,59 +193,89 @@ 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):
+            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.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():
-                if (item / "__init__.py").exists() or (item / "plugin.py").exists():
+                # 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__':
+
+            elif item.suffix == ".py" and item.stem != "__init__":
                 plugins.append(item.stem)
-    
-    return sorted(set(plugins))
+
+    # Add builtin plugins
+    builtin_plugins = BuiltinPluginRegistry.list_builtin_plugins()
+    plugins.extend(builtin_plugins)
+
+    return sorted(set(plugins))

janito/plugins/manager.py

@@ -13,6 +13,7 @@ import logging
 from .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__)
@@ -22,13 +23,13 @@ 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)
@@ -36,15 +37,17 @@ class PluginManager:
             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:
+
+    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
         """
@@ -52,47 +55,47 @@ class PluginManager:
             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 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
         """
@@ -100,65 +103,65 @@ class PluginManager:
             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)
+                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', {})
-        
+        plugins_config = config.get("plugins", {})
+
         # Add plugin paths
-        for path in plugins_config.get('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():
+        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.
@@ -166,62 +169,63 @@ class PluginManager:
         """
         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, {}),
-                'resources': [
+                "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
+                        "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
+                "name": resource.name,
+                "type": resource.type,
+                "description": resource.description,
+                "schema": resource.schema,
             }
             for resource in plugin.get_resources()
         ]
@@ -229,11 +233,11 @@ class PluginManager:
     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
+        return all_resources