janito 2.27.1__py3-none-any.whl → 2.29.0__py3-none-any.whl

janito/plugins/builtin.py

@@ -12,24 +12,24 @@ from janito.plugins.base import Plugin
 
 class BuiltinPluginRegistry:
     """Registry for builtin plugins that come packaged with janito."""
-    
+
     _plugins: Dict[str, Type[Plugin]] = {}
-    
+
     @classmethod
     def register(cls, name: str, plugin_class: Type[Plugin]) -> None:
         """Register a builtin plugin."""
         cls._plugins[name] = plugin_class
-    
+
     @classmethod
     def get_plugin_class(cls, name: str) -> Optional[Type[Plugin]]:
         """Get the plugin class for a builtin plugin."""
         return cls._plugins.get(name)
-    
+
     @classmethod
     def list_builtin_plugins(cls) -> List[str]:
         """List all registered builtin plugins."""
         return list(cls._plugins.keys())
-    
+
     @classmethod
     def is_builtin(cls, name: str) -> bool:
         """Check if a plugin is builtin."""
@@ -38,9 +38,11 @@ class BuiltinPluginRegistry:
 
 def register_builtin_plugin(name: str):
     """Decorator to register a plugin as builtin."""
+
     def decorator(plugin_class: Type[Plugin]) -> Type[Plugin]:
         BuiltinPluginRegistry.register(name, plugin_class)
         return plugin_class
+
     return decorator
 
 
@@ -66,7 +68,7 @@ try:
         SecurityScannerPlugin,
         DocumentationGeneratorPlugin,
     )
-    
+
     # Register all janito-coder plugins as builtin
     BuiltinPluginRegistry.register("git_analyzer", GitAnalyzerPlugin)
     BuiltinPluginRegistry.register("code_navigator", CodeNavigatorPlugin)
@@ -77,8 +79,10 @@ try:
     BuiltinPluginRegistry.register("debugger", DebuggerPlugin)
     BuiltinPluginRegistry.register("performance_profiler", PerformanceProfilerPlugin)
     BuiltinPluginRegistry.register("security_scanner", SecurityScannerPlugin)
-    BuiltinPluginRegistry.register("documentation_generator", DocumentationGeneratorPlugin)
-    
+    BuiltinPluginRegistry.register(
+        "documentation_generator", DocumentationGeneratorPlugin
+    )
+
 except ImportError:
     # janito-coder not available, skip registration
-    pass
+    pass

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

@@ -37,36 +37,38 @@ 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(".")
@@ -76,33 +78,33 @@ def discover_plugins(plugin_name: str, search_paths: List[Path] = None) -> Optio
                 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
 
 
@@ -112,74 +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__'):
+        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')
+                        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__', [])
-                
+                    return getattr(module, "__plugin_tools__", [])
+
                 def initialize(self):
-                    if hasattr(module, 'initialize'):
+                    if hasattr(module, "initialize"):
                         module.initialize()
-                
+
                 def cleanup(self):
-                    if hasattr(module, 'cleanup'):
+                    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
 
 
@@ -187,54 +193,52 @@ 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():
@@ -245,30 +249,33 @@ def list_available_plugins(search_paths: List[Path] = None) -> List[str]:
                         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"
+                                    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__'))
+                                    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)
-    
+
     # Add builtin plugins
     builtin_plugins = BuiltinPluginRegistry.list_builtin_plugins()
     plugins.extend(builtin_plugins)
-    
-    return sorted(set(plugins))
+
+    return sorted(set(plugins))