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

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))

janito/plugins/manager.py

@@ -23,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)
@@ -37,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
         """
@@ -53,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
         """
@@ -101,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.
@@ -167,63 +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, {}),
-                'builtin': BuiltinPluginRegistry.is_builtin(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()
         ]
@@ -231,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

janito/provider_registry.py

@@ -39,16 +39,16 @@ class ProviderRegistry:
             if len(info) == 4 and info[3]:
                 continue  # skip providers flagged as not implemented
             rows.append(info[:3])
-        
+
         # Group providers by openness (open-source first, then proprietary)
-        open_providers = {'cerebras', 'deepseek', 'alibaba', 'moonshotai', 'zai'}
-        
+        open_providers = {"cerebras", "deepseek", "alibaba", "moonshotai", "zai"}
+
         def sort_key(row):
             provider_name = row[0]
             is_open = provider_name in open_providers
             # Sort open providers alphabetically first, then proprietary alphabetically
             return (not is_open, provider_name)
-        
+
         rows.sort(key=sort_key)
         return rows
 
@@ -101,21 +101,21 @@ class ProviderRegistry:
             model_specs = None
             if hasattr(model_info_mod, "MODEL_SPECS"):
                 model_specs = model_info_mod.MODEL_SPECS
-            elif hasattr(model_info_mod, "MOONSHOTAI_MODEL_SPECS"):
-                model_specs = model_info_mod.MOONSHOTAI_MODEL_SPECS
-            
+            elif hasattr(model_info_mod, "MOONSHOT_MODEL_SPECS"):
+                model_specs = model_info_mod.MOONSHOT_MODEL_SPECS
+
             if model_specs:
                 default_model = getattr(provider_class, "DEFAULT_MODEL", None)
                 model_names = []
-                
+
                 for model_key in model_specs.keys():
                     if model_key == default_model:
                         # Highlight the default model with color and star icon
                         model_names.append(f"[bold green]⭐ {model_key}[/bold green]")
                     else:
                         model_names.append(model_key)
-                
-                if provider_name == "moonshotai":
+
+                if provider_name == "moonshot":
                     return ", ".join(model_names)
                 return ", ".join(model_names)
             return "-"

janito/providers/__init__.py

@@ -4,7 +4,7 @@ import janito.providers.google.provider
 import janito.providers.azure_openai.provider
 import janito.providers.anthropic.provider
 import janito.providers.deepseek.provider
-import janito.providers.moonshotai.provider
+import janito.providers.moonshot.provider
 import janito.providers.alibaba.provider
 import janito.providers.zai.provider
 import janito.providers.cerebras.provider