janito 3.3.0__tar.gz → 3.4.0__tar.gz

{janito-3.3.0 → janito-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 3.3.0
+Version: 3.4.0
 Summary: A new Python package called janito.
 Author-email: João Pinto <janito@ikignosis.org>
 Project-URL: Homepage, https://github.com/ikignosis/janito
@@ -30,6 +30,7 @@ Requires-Dist: black; extra == "dev"
 Requires-Dist: questionary>=2.0.1; extra == "dev"
 Requires-Dist: setuptools_scm>=8.0; extra == "dev"
 Provides-Extra: coder
+Requires-Dist: janito-coder; extra == "coder"
 Dynamic: license-file
 
 # nctl

{janito-3.3.0 → janito-3.4.0}/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-3.3.0 → janito-3.4.0}/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-3.3.0 → janito-3.4.0}/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-3.3.0 → janito-3.4.0}/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-3.3.0 → janito-3.4.0}/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-3.4.0/janito/llm/auth_utils.py

@@ -0,0 +1,21 @@
+"""
+Authentication utilities for LLM providers.
+"""
+
+import sys
+
+
+def handle_missing_api_key(provider_name: str, env_var_name: str) -> None:
+    """
+    Handle missing API key by printing error message and exiting.
+
+    Args:
+        provider_name: Name of the provider (e.g., 'alibaba', 'openai')
+        env_var_name: Environment variable name (e.g., 'ALIBABA_API_KEY')
+    """
+    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-3.4.0/janito/plugins/__init__.py

@@ -0,0 +1,17 @@
+"""
+Plugin system for janito.
+
+This package provides a flexible plugin system that allows extending
+janito's functionality with custom tools, commands, and features.
+"""
+
+from .manager import PluginManager
+from .base import Plugin, PluginMetadata
+from .discovery import discover_plugins
+
+__all__ = [
+    "PluginManager",
+    "Plugin",
+    "PluginMetadata",
+    "discover_plugins",
+]

{janito-3.3.0/janito/plugins_backup_20250825_070018 → janito-3.4.0/janito/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-3.3.0/janito/plugin_system_backup_20250825_070018 → janito-3.4.0/janito/plugins}/base.py

@@ -5,10 +5,7 @@ Base classes for janito plugins.
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import Dict, Any, List, Optional, Type, Union
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from janito.tools.tool_base import ToolBase
+from janito.tools.tool_base import ToolBase
 
 
 @dataclass
@@ -53,7 +50,7 @@ class Plugin(ABC):
         """Return metadata describing this plugin."""
         pass
 
-    def get_tools(self) -> List[Type["ToolBase"]]:
+    def get_tools(self) -> List[Type[ToolBase]]:
         """
         Return a list of tool classes provided by this plugin.
 

{janito-3.3.0 → janito-3.4.0}/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

{janito-3.3.0/janito/plugins_backup_20250825_070018 → janito-3.4.0/janito/plugins}/core_adapter.py

@@ -5,7 +5,7 @@ This module provides proper Plugin class implementations for core plugins
 that use the function-based approach instead of class-based.
 """
 
-from janito.plugin_system.base import Plugin, PluginMetadata
+from janito.plugins.base import Plugin, PluginMetadata
 from typing import List, Type
 from janito.tools.tool_base import ToolBase
 from janito.tools.function_adapter import create_function_tool
@@ -13,17 +13,17 @@ from janito.tools.function_adapter import create_function_tool
 
 class CorePluginAdapter(Plugin):
     """Adapter for core plugins using function-based tools."""
-
+    
     def __init__(self, plugin_name: str, description: str, tools_module):
         super().__init__()
         self._plugin_name = plugin_name
         self._description = description
         self._tools_module = tools_module
         self._tool_classes = []
-
+        
         # Set the metadata attribute that Plugin expects
         self.metadata = self.get_metadata()
-
+        
     def get_metadata(self) -> PluginMetadata:
         return PluginMetadata(
             name=self._plugin_name,
@@ -32,15 +32,15 @@ class CorePluginAdapter(Plugin):
             author="Janito",
             license="MIT",
         )
-
+    
     def get_tools(self) -> List[Type[ToolBase]]:
         return self._tool_classes
-
+    
     def initialize(self):
         """Initialize the plugin by creating tool classes."""
         # Get tools from the module
         tools = getattr(self._tools_module, "__plugin_tools__", [])
-
+        
         self._tool_classes = []
         for tool_func in tools:
             if callable(tool_func):
@@ -48,8 +48,6 @@ class CorePluginAdapter(Plugin):
                 self._tool_classes.append(tool_class)
 
 
-def create_core_plugin(
-    plugin_name: str, description: str, tools_module
-) -> CorePluginAdapter:
+def create_core_plugin(plugin_name: str, description: str, tools_module) -> CorePluginAdapter:
     """Create a core plugin adapter."""
-    return CorePluginAdapter(plugin_name, description, tools_module)
+    return CorePluginAdapter(plugin_name, description, tools_module)

{janito-3.3.0/janito/plugin_system_backup_20250825_070018 → janito-3.4.0/janito/plugins}/core_loader.py

@@ -1,31 +1,30 @@
 """
-Fixed core plugin loader.
+Core plugin loader that properly handles function-based plugins.
 
-This module provides a working implementation to load core plugins
-by directly using the Plugin base class properly.
+This module provides a simplified approach to load core plugins
+without the complex discovery mechanism.
 """
 
-import importlib
 import importlib.util
 import sys
 from pathlib import Path
-from typing import Optional, List, Type
+from typing import Optional
 
-from janito.plugin_system.base import Plugin, PluginMetadata
+from janito.plugins.base import Plugin, PluginMetadata
 from janito.tools.function_adapter import create_function_tool
 from janito.tools.tool_base import ToolBase
 
 
 class CorePlugin(Plugin):
-    """Working core plugin implementation."""
-
+    """Simple core plugin implementation."""
+    
     def __init__(self, name: str, description: str, tools: list):
+        super().__init__()
         self._plugin_name = name
         self._description = description
         self._tools = tools
         self._tool_classes = []
-        super().__init__()  # Call super after setting attributes
-
+        
     def get_metadata(self) -> PluginMetadata:
         return PluginMetadata(
             name=self._plugin_name,
@@ -34,10 +33,10 @@ class CorePlugin(Plugin):
             author="Janito",
             license="MIT",
         )
-
-    def get_tools(self) -> List[Type[ToolBase]]:
+    
+    def get_tools(self) -> list:
         return self._tool_classes
-
+    
     def initialize(self):
         """Initialize by creating tool classes."""
         self._tool_classes = []
@@ -50,10 +49,10 @@ class CorePlugin(Plugin):
 def load_core_plugin(plugin_name: str) -> Optional[Plugin]:
     """
     Load a core plugin by name.
-
+    
     Args:
         plugin_name: Name of the plugin (e.g., 'core.filemanager')
-
+        
     Returns:
         Plugin instance if loaded successfully
     """
@@ -61,67 +60,39 @@ def load_core_plugin(plugin_name: str) -> Optional[Plugin]:
         # Parse plugin name
         if "." not in plugin_name:
             return None
-
+            
         parts = plugin_name.split(".")
         if len(parts) != 2:
             return None
-
+            
         package_name, submodule_name = parts
-
-        # Handle imagedisplay specially
-        if plugin_name == "core.imagedisplay":
-            # Import the actual plugin class
-            try:
-                # Use dynamic import to avoid circular dependency
-                plugin_module = importlib.import_module(
-                    "janito.plugins.core.imagedisplay.plugin"
-                )
-                return plugin_module.ImageDisplayPlugin()
-            except ImportError as e:
-                print(f"Failed to load imagedisplay: {e}")
-                return None
-
+        
         # Build path to plugin
-        plugin_path = (
-            Path("janito/plugins") / package_name / submodule_name / "__init__.py"
-        )
+        plugin_path = Path("plugins") / package_name / submodule_name / "__init__.py"
         if not plugin_path.exists():
             return None
-
+            
         # Load the module
         spec = importlib.util.spec_from_file_location(plugin_name, plugin_path)
         if spec is None or spec.loader is None:
             return None
-
+            
         module = importlib.util.module_from_spec(spec)
         spec.loader.exec_module(module)
-
+        
         # Get plugin info
         name = getattr(module, "__plugin_name__", plugin_name)
-        description = getattr(
-            module, "__plugin_description__", f"Core plugin: {plugin_name}"
-        )
+        description = getattr(module, "__plugin_description__", f"Core plugin: {plugin_name}")
         tools = getattr(module, "__plugin_tools__", [])
-
+        
         if not tools:
             return None
-
-        # Filter out None values and ensure all tools have tool_name
-        valid_tools = []
-        for tool in tools:
-            if tool is not None:
-                if not hasattr(tool, "tool_name"):
-                    tool.tool_name = tool.__name__
-                valid_tools.append(tool)
-
-        if not valid_tools:
-            return None
-
+            
         # Create plugin
-        plugin = CorePlugin(name, description, valid_tools)
+        plugin = CorePlugin(name, description, tools)
         plugin.initialize()
         return plugin
-
+        
     except Exception as e:
         print(f"Error loading core plugin {plugin_name}: {e}")
         return None
@@ -139,6 +110,11 @@ def get_core_plugins() -> list:
         "ui.userinterface",
         "web.webtools",
     ]
-
-    # All core plugins are always available
-    return core_plugins
+    
+    available = []
+    for plugin_name in core_plugins:
+        plugin = load_core_plugin(plugin_name)
+        if plugin:
+            available.append(plugin_name)
+    
+    return available