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

janito/cli/cli_commands/list_plugins.py

@@ -8,8 +8,7 @@ from janito.plugins.discovery import list_available_plugins
 import os
 from janito.plugins.manager import PluginManager
 from janito.plugins.builtin import BuiltinPluginRegistry
-from janito.plugins.manager import PluginManager
-from janito.plugins.core_loader import get_core_plugins
+from janito.plugins.auto_loader_fixed import load_core_plugins, get_loaded_core_plugins, is_core_plugin
 from rich.console import Console
 from rich.table import Table
 from rich.panel import Panel
@@ -52,8 +51,7 @@ def _list_available_plugins():
         console.print(table)
 
         # Show core plugins
-        from janito.plugins.core_loader import get_core_plugins
-
+        from janito.plugins.core_loader_fixed import get_core_plugins
         core_plugins = get_core_plugins()
         core_table = Table(title="Core Plugins (Enabled by Default)")
         core_table.add_column("Plugin Name", style="cyan", no_wrap=True)
@@ -64,16 +62,14 @@ def _list_available_plugins():
 
         console.print(core_table)
     else:
-        console.print(
-            Panel(
-                "No plugins found in search paths\n"
-                f"[dim]Search paths:[/dim]\n"
-                f"  • {os.getcwd()}/plugins\n"
-                f"  • {os.path.expanduser('~')}/.janito/plugins",
-                title="No Plugins Found",
-                style="yellow",
-            )
-        )
+        console.print(Panel(
+            "No plugins found in search paths\n"
+            f"[dim]Search paths:[/dim]\n"
+            f"  • {os.getcwd()}/plugins\n"
+            f"  • {os.path.expanduser('~')}/.janito/plugins",
+            title="No Plugins Found",
+            style="yellow"
+        ))
 
 
 def _print_builtin_plugins(builtin_plugins):
@@ -95,18 +91,20 @@ def _print_external_plugins(available, builtin_plugins):
 
 def _list_plugin_resources():
     """List all resources from loaded plugins using rich formatting."""
+    from janito.plugins.auto_loader_fixed import get_plugin_manager
+    
     console = Console()
-    manager = PluginManager()
+    manager = get_plugin_manager()
     all_resources = manager.list_all_resources()
 
     if all_resources:
         for plugin_name, resources in all_resources.items():
             metadata = manager.get_plugin_metadata(plugin_name)
-            version = metadata.version if metadata else "unknown"
-
+            version = metadata.version if metadata else 'unknown'
+            
             # Create panel for each plugin
             panel_content = []
-
+            
             tools = [r for r in resources if r["type"] == "tool"]
             commands = [r for r in resources if r["type"] == "command"]
             configs = [r for r in resources if r["type"] == "config"]
@@ -124,25 +122,19 @@ def _list_plugin_resources():
             if configs:
                 panel_content.append("[bold yellow]Configuration:[/bold yellow]")
                 for config in configs:
-                    panel_content.append(
-                        f"  • {config['name']}: {config['description']}"
-                    )
-
-            console.print(
-                Panel(
-                    "\n".join(panel_content),
-                    title=f"{plugin_name} v{version}",
-                    style="cyan",
-                )
-            )
+                    panel_content.append(f"  • {config['name']}: {config['description']}")
+
+            console.print(Panel(
+                "\n".join(panel_content),
+                title=f"{plugin_name} v{version}",
+                style="cyan"
+            ))
     else:
-        console.print(
-            Panel(
-                "No plugins are currently loaded.",
-                title="No Plugin Resources",
-                style="yellow",
-            )
-        )
+        console.print(Panel(
+            "No plugins are currently loaded.",
+            title="No Plugin Resources",
+            style="yellow"
+        ))
 
 
 def _print_resources_by_type(resources):
@@ -169,8 +161,10 @@ def _print_resources_by_type(resources):
 
 def _list_loaded_plugins():
     """List loaded plugins using rich formatting."""
+    from janito.plugins.auto_loader_fixed import get_plugin_manager
+    
     console = Console()
-    manager = PluginManager()
+    manager = get_plugin_manager()
     loaded = manager.list_plugins()
 
     if loaded:
@@ -183,40 +177,42 @@ def _list_loaded_plugins():
 
         core_plugins = []
         other_plugins = []
-
+        
         for plugin_name in loaded:
-            from janito.plugins.core_loader import get_core_plugins
-            core_plugin_list = get_core_plugins()
-            if plugin_name in core_plugin_list:
+            if is_core_plugin(plugin_name):
                 core_plugins.append(plugin_name)
             else:
                 other_plugins.append(plugin_name)
-
+        
         # Add core plugins
         for plugin_name in core_plugins:
             metadata = manager.get_plugin_metadata(plugin_name)
             if metadata:
                 table.add_row(
-                    metadata.name, metadata.version, metadata.description, "🔵 Core"
+                    metadata.name,
+                    metadata.version,
+                    metadata.description,
+                    "🔵 Core"
                 )
-
+        
         # Add other plugins
         for plugin_name in other_plugins:
             metadata = manager.get_plugin_metadata(plugin_name)
             if metadata:
                 table.add_row(
-                    metadata.name, metadata.version, metadata.description, "🔶 External"
+                    metadata.name,
+                    metadata.version,
+                    metadata.description,
+                    "🔶 External"
                 )
 
         console.print(table)
     else:
-        console.print(
-            Panel(
-                "No plugins are currently loaded.",
-                title="No Plugins Loaded",
-                style="yellow",
-            )
-        )
+        console.print(Panel(
+            "No plugins are currently loaded.",
+            title="No Plugins Loaded",
+            style="yellow"
+        ))
 
 
 def _print_plugin_details(manager, plugin_name):

janito/cli/core/getters.py

@@ -5,7 +5,6 @@ import sys
 from janito.cli.cli_commands.list_providers import handle_list_providers
 from janito.cli.cli_commands.list_models import handle_list_models
 from janito.cli.cli_commands.list_tools import handle_list_tools
-from janito.cli.cli_commands.check_tools import handle_check_tools
 from janito.cli.cli_commands.show_config import handle_show_config
 from janito.cli.cli_commands.list_config import handle_list_config
 from janito.cli.cli_commands.list_drivers import handle_list_drivers
@@ -29,7 +28,6 @@ GETTER_KEYS = [
     "list_plugins",
     "list_plugins_available",
     "list_resources",
-    "check_tools",
 ]
 
 
@@ -66,7 +64,6 @@ def handle_getter(args, config_mgr=None):
         "list_plugins": partial(handle_list_plugins, args),
         "list_plugins_available": partial(handle_list_plugins, args),
         "list_resources": partial(handle_list_plugins, args),
-        "check_tools": partial(handle_check_tools, args),
     }
     for arg in GETTER_KEYS:
         if getattr(args, arg, False) and arg in GETTER_DISPATCH:

janito/cli/main_cli.py

@@ -238,13 +238,6 @@ definition = [
             "help": "List all resources (tools, commands, config) from loaded plugins",
         },
     ),
-    (
-        ["--check-tools"],
-        {
-            "action": "store_true",
-            "help": "Check all registered tools for signature validation and availability",
-        },
-    ),
 ]
 
 MODIFIER_KEYS = [
@@ -276,7 +269,18 @@ GETTER_KEYS = [
     "region_info",
     "list_providers_region",
     "ping",
-    "check_tools",
+]
+GETTER_KEYS = [
+    "show_config",
+    "list_providers",
+    "list_profiles",
+    "list_models",
+    "list_tools",
+    "list_config",
+    "list_drivers",
+    "region_info",
+    "list_providers_region",
+    "ping",
 ]
 
 
@@ -402,7 +406,6 @@ class JanitoCLI:
             or self.args.list_plugins_available
             or self.args.list_resources
             or self.args.ping
-            or self.args.check_tools
         ):
             self._maybe_print_verbose_provider_model()
             handle_getter(self.args)

janito/drivers/openai/driver.py

@@ -181,7 +181,6 @@ class OpenAIModelDriver(LLMDriver):
         is_insufficient_quota = (
             "insufficient_quota" in lower_err
             or "exceeded your current quota" in lower_err
-            or "exceeded_current_quota_error" in lower_err
         )
         is_rate_limit = (
             status_code == 429

janito/drivers/zai/driver.py

@@ -174,7 +174,6 @@ class ZAIModelDriver(LLMDriver):
         is_insufficient_quota = (
             "insufficient_quota" in lower_err
             or "exceeded your current quota" in lower_err
-            or "exceeded_current_quota_error" in lower_err
         )
         is_rate_limit = (
             status_code == 429

janito/llm/auth_utils.py

@@ -13,18 +13,9 @@ def handle_missing_api_key(provider_name: str, env_var_name: str) -> None:
         provider_name: Name of the provider (e.g., 'alibaba', 'openai')
         env_var_name: Environment variable name (e.g., 'ALIBABA_API_KEY')
     """
-    if provider_name == "moonshot":
-        print(
-            f"[ERROR] You exceeded your current token quota for Moonshot. Please check your account balance at:"
-        )
-        print(f"  https://platform.moonshot.ai/console/pay")
-        print()
-        print(f"To set a new API key, use:")
-        print(f"  janito --set-api-key YOUR_NEW_API_KEY -p moonshot")
-    else:
-        print(
-            f"[ERROR] No API key found for provider '{provider_name}'. Please set the API key using:"
-        )
-        print(f"  janito --set-api-key YOUR_API_KEY -p {provider_name}")
-        print(f"Or set the {env_var_name} environment variable.")
+    print(
+        f"[ERROR] No API key found for provider '{provider_name}'. Please set the API key using:"
+    )
+    print(f"  janito --set-api-key YOUR_API_KEY -p {provider_name}")
+    print(f"Or set the {env_var_name} environment variable.")
     sys.exit(1)

janito/plugins/__init__.py

@@ -1,28 +1,17 @@
 """
-Unified Plugin System for Janito
+Plugin system for janito.
 
-This package provides a clean, unified plugin architecture for janito.
+This package provides a flexible plugin system that allows extending
+janito's functionality with custom tools, commands, and features.
 """
 
-__version__ = "1.0.0"
-__author__ = "Development Assistant"
-
-# Import core components
-from .base import Plugin, PluginMetadata, PluginResource
 from .manager import PluginManager
-from .discovery import discover_plugins, list_available_plugins
-from .config import load_plugins_config, save_plugins_config
-from .builtin import BuiltinPluginRegistry, load_builtin_plugin
+from .base import Plugin, PluginMetadata
+from .discovery import discover_plugins
 
 __all__ = [
-    "Plugin",
-    "PluginMetadata", 
-    "PluginResource",
     "PluginManager",
+    "Plugin",
+    "PluginMetadata",
     "discover_plugins",
-    "list_available_plugins",
-    "load_plugins_config",
-    "save_plugins_config",
-    "BuiltinPluginRegistry",
-    "load_builtin_plugin",
 ]

janito/{plugins_backup_20250825_070018 → plugins}/auto_loader_fixed.py

@@ -9,12 +9,12 @@ import os
 from pathlib import Path
 from typing import List
 from janito.plugins.manager import PluginManager
-from janito.plugin_system.core_loader_fixed import load_core_plugin, get_core_plugins
+from janito.plugins.core_loader_fixed import load_core_plugin, get_core_plugins
 
 # List of core plugins that should be enabled by default
 CORE_PLUGINS = [
     "core.filemanager",
-    "core.codeanalyzer",
+    "core.codeanalyzer", 
     "core.system",
     "core.imagedisplay",
     "dev.pythondev",
@@ -27,18 +27,18 @@ CORE_PLUGINS = [
 def load_core_plugins(pm: PluginManager = None) -> List[str]:
     """
     Load all core plugins.
-
+    
     Args:
         pm: PluginManager instance. If None, creates a new one.
-
+        
     Returns:
         List of successfully loaded plugin names
     """
     if pm is None:
         pm = PluginManager()
-
+    
     loaded = []
-
+    
     # Load core plugins
     for plugin_name in CORE_PLUGINS:
         try:
@@ -49,14 +49,14 @@ def load_core_plugins(pm: PluginManager = None) -> List[str]:
                 loaded.append(plugin_name)
         except Exception as e:
             print(f"Warning: Failed to load core plugin {plugin_name}: {e}")
-
+    
     return loaded
 
 
 def get_loaded_core_plugins() -> List[str]:
     """
     Get list of currently loaded core plugins.
-
+    
     Returns:
         List of loaded core plugin names
     """
@@ -68,10 +68,10 @@ def get_loaded_core_plugins() -> List[str]:
 def is_core_plugin(plugin_name: str) -> bool:
     """
     Check if a plugin is a core plugin.
-
+    
     Args:
         plugin_name: Name of the plugin to check
-
+        
     Returns:
         True if it's a core plugin
     """
@@ -81,11 +81,10 @@ def is_core_plugin(plugin_name: str) -> bool:
 # Auto-load core plugins when module is imported
 _plugin_manager = None
 
-
 def get_plugin_manager() -> PluginManager:
     """Get the global plugin manager with core plugins loaded."""
     global _plugin_manager
     if _plugin_manager is None:
         _plugin_manager = PluginManager()
         load_core_plugins(_plugin_manager)
-    return _plugin_manager
+    return _plugin_manager

janito/plugins/base.py

@@ -1,57 +1,152 @@
-"""
-Base classes for janito plugins.
-"""
-
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from typing import Dict, Any, List, Optional, Type
-
-@dataclass
-class PluginMetadata:
-    name: str
-    version: str
-    description: str
-    author: str
-    license: str = "MIT"
-    homepage: Optional[str] = None
-    dependencies: List[str] = None
-
-    def __post_init__(self):
-        if self.dependencies is None:
-            self.dependencies = []
-
-@dataclass
-class PluginResource:
-    name: str
-    type: str
-    description: str
-    schema: Optional[Dict[str, Any]] = None
-
-class Plugin(ABC):
-    def __init__(self):
-        self.metadata: PluginMetadata = self.get_metadata()
-
-    @abstractmethod
-    def get_metadata(self) -> PluginMetadata:
-        pass
-
-    def get_tools(self):
-        return []
-
-    def get_commands(self):
-        return {}
-
-    def initialize(self):
-        pass
-
-    def cleanup(self):
-        pass
-
-    def get_config_schema(self):
-        return {}
-
-    def validate_config(self, config):
-        return True
-
-    def get_resources(self):
-        return []
+"""
+Base classes for janito plugins.
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Dict, Any, List, Optional, Type, Union
+from janito.tools.tool_base import ToolBase
+
+
+@dataclass
+class PluginMetadata:
+    """Metadata describing a plugin."""
+
+    name: str
+    version: str
+    description: str
+    author: str
+    license: str = "MIT"
+    homepage: Optional[str] = None
+    dependencies: List[str] = None
+
+    def __post_init__(self):
+        if self.dependencies is None:
+            self.dependencies = []
+
+
+@dataclass
+class PluginResource:
+    """Represents a resource provided by a plugin."""
+
+    name: str
+    type: str  # "tool", "command", "config"
+    description: str
+    schema: Optional[Dict[str, Any]] = None
+
+
+class Plugin(ABC):
+    """
+    Base class for all janito plugins.
+
+    Plugins can provide tools, commands, or other functionality.
+    """
+
+    def __init__(self):
+        self.metadata: PluginMetadata = self.get_metadata()
+
+    @abstractmethod
+    def get_metadata(self) -> PluginMetadata:
+        """Return metadata describing this plugin."""
+        pass
+
+    def get_tools(self) -> List[Type[ToolBase]]:
+        """
+        Return a list of tool classes provided by this plugin.
+
+        Returns:
+            List of ToolBase subclasses that should be registered
+        """
+        return []
+
+    def get_commands(self) -> Dict[str, Any]:
+        """
+        Return a dictionary of CLI commands provided by this plugin.
+
+        Returns:
+            Dict mapping command names to command handlers
+        """
+        return {}
+
+    def initialize(self) -> None:
+        """
+        Called when the plugin is loaded.
+        Override to perform any initialization needed.
+        """
+        pass
+
+    def cleanup(self) -> None:
+        """
+        Called when the plugin is unloaded.
+        Override to perform any cleanup needed.
+        """
+        pass
+
+    def get_config_schema(self) -> Dict[str, Any]:
+        """
+        Return JSON schema for plugin configuration.
+
+        Returns:
+            JSON schema dict describing configuration options
+        """
+        return {}
+
+    def validate_config(self, config: Dict[str, Any]) -> bool:
+        """
+        Validate plugin configuration.
+
+        Args:
+            config: Configuration dict to validate
+
+        Returns:
+            True if configuration is valid
+        """
+        return True
+
+    def get_resources(self) -> List[PluginResource]:
+        """
+        Return a list of resources provided by this plugin.
+
+        Returns:
+            List of PluginResource objects describing the resources
+        """
+        resources = []
+
+        # Add tools as resources
+        for tool_class in self.get_tools():
+            tool_instance = tool_class()
+            tool_name = getattr(tool_instance, "tool_name", tool_class.__name__)
+            tool_desc = getattr(tool_class, "__doc__", f"Tool: {tool_name}")
+            resources.append(
+                PluginResource(
+                    name=tool_name,
+                    type="tool",
+                    description=tool_desc or f"Tool provided by {self.metadata.name}",
+                )
+            )
+
+        # Add commands as resources
+        commands = self.get_commands()
+        for cmd_name, cmd_handler in commands.items():
+            cmd_desc = getattr(cmd_handler, "__doc__", f"Command: {cmd_name}")
+            resources.append(
+                PluginResource(
+                    name=cmd_name,
+                    type="command",
+                    description=cmd_desc or f"Command provided by {self.metadata.name}",
+                )
+            )
+
+        # Add config schema as resource
+        config_schema = self.get_config_schema()
+        if config_schema:
+            resources.append(
+                PluginResource(
+                    name=f"{self.metadata.name}_config",
+                    type="config",
+                    description=f"Configuration schema for {self.metadata.name} plugin",
+                    schema=config_schema,
+                )
+            )
+
+        return resources

janito/plugins/builtin.py

@@ -7,7 +7,7 @@ with janito and available by default without requiring external installation.
 
 import importlib
 from typing import Dict, List, Optional, Type
-from .base import Plugin
+from janito.plugins.base import Plugin
 
 
 class BuiltinPluginRegistry:
@@ -83,20 +83,6 @@ try:
         "documentation_generator", DocumentationGeneratorPlugin
     )
 
-    # Register core tools plugin
-    from janito.plugins.tools import CoreToolsPlugin
-
-    BuiltinPluginRegistry.register("core_tools", CoreToolsPlugin)
-
 except ImportError:
     # janito-coder not available, skip registration
     pass
-
-# Register core tools plugin (always available)
-try:
-    from janito.plugins.tools import CoreToolsPlugin
-
-    BuiltinPluginRegistry.register("core_tools", CoreToolsPlugin)
-except ImportError:
-    # Should not happen, but handle gracefully
-    pass