janito 2.24.1__py3-none-any.whl → 2.26.0__py3-none-any.whl

janito/cli/chat_mode/session.py

@@ -116,12 +116,12 @@ class ChatSession:
     def _select_profile_and_role(self, args, role):
         profile = getattr(args, "profile", None) if args is not None else None
         role_arg = getattr(args, "role", None) if args is not None else None
-        python_profile = getattr(args, "python", False) if args is not None else False
+        python_profile = getattr(args, "developer", False) if args is not None else False
         market_profile = getattr(args, "market", False) if args is not None else False
         profile_system_prompt = None
         no_tools_mode = False
 
-        # Handle --python flag
+        # Handle --developer flag
         if python_profile and profile is None and role_arg is None:
             profile = "Developer with Python Tools"
 

janito/cli/chat_mode/shell/commands/unrestricted.py

@@ -0,0 +1,40 @@
+"""Unrestricted mode command for chat mode."""
+
+from janito.cli.chat_mode.shell.commands.base import ShellCmdHandler
+from janito.cli.console import shared_console
+
+
+class UnrestrictedShellHandler(ShellCmdHandler):
+    """Toggle unrestricted mode (equivalent to -u CLI flag)."""
+    
+    help_text = "Toggle unrestricted mode (disable path security and URL whitelist)"
+
+    def run(self):
+        """Execute the unrestricted command."""
+        if not self.shell_state:
+            shared_console.print("[red]Error: Shell state not available[/red]")
+            return
+            
+        # Toggle unrestricted mode
+        current_unrestricted = getattr(self.shell_state, 'unrestricted_mode', False)
+        new_unrestricted = not current_unrestricted
+        
+        # Update shell state
+        self.shell_state.unrestricted_mode = new_unrestricted
+        
+        # Update tools adapter
+        if hasattr(self.shell_state, 'tools_adapter'):
+            setattr(self.shell_state.tools_adapter, 'unrestricted_paths', new_unrestricted)
+            
+        # Update URL whitelist manager
+        from janito.tools.url_whitelist import get_url_whitelist_manager
+        whitelist_manager = get_url_whitelist_manager()
+        whitelist_manager.set_unrestricted_mode(new_unrestricted)
+        
+        status = "enabled" if new_unrestricted else "disabled"
+        warning = " (DANGEROUS - no path or URL restrictions)" if new_unrestricted else ""
+        
+        shared_console.print(
+            f"[bold {'red' if new_unrestricted else 'green'}]"
+            f"Unrestricted mode {status}{warning}[/bold {'red' if new_unrestricted else 'green'}]"
+        )

janito/cli/cli_commands/list_plugins.py

@@ -24,6 +24,38 @@ def handle_list_plugins(args: argparse.Namespace) -> None:
             print("Search paths:")
             print(f"  - {os.getcwd()}/plugins")
             print(f"  - {os.path.expanduser('~')}/.janito/plugins")
+    elif getattr(args, 'list_resources', False):
+        # List all resources from loaded plugins
+        manager = PluginManager()
+        all_resources = manager.list_all_resources()
+        
+        if all_resources:
+            print("Plugin Resources:")
+            for plugin_name, resources in all_resources.items():
+                metadata = manager.get_plugin_metadata(plugin_name)
+                print(f"\n{plugin_name} v{metadata.version if metadata else 'unknown'}:")
+                
+                # Group resources by type
+                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']
+                
+                if tools:
+                    print("  Tools:")
+                    for tool in tools:
+                        print(f"    - {tool['name']}: {tool['description']}")
+                
+                if commands:
+                    print("  Commands:")
+                    for cmd in commands:
+                        print(f"    - {cmd['name']}: {cmd['description']}")
+                
+                if configs:
+                    print("  Configuration:")
+                    for config in configs:
+                        print(f"    - {config['name']}: {config['description']}")
+        else:
+            print("No plugins loaded")
     else:
         # List loaded plugins
         manager = PluginManager()

janito/cli/core/getters.py

@@ -26,6 +26,7 @@ GETTER_KEYS = [
     "list_providers_region",
     "list_plugins",
     "list_plugins_available",
+    "list_resources",
 ]
 
 
@@ -55,6 +56,7 @@ def handle_getter(args, config_mgr=None):
         "region_info": partial(handle_region_info, args),
         "list_providers_region": partial(handle_list_providers_region, args),
         "list_plugins": partial(handle_list_plugins, args),
+        "list_resources": partial(handle_list_plugins, args),
     }
     for arg in GETTER_KEYS:
         if getattr(args, arg, False) and arg in GETTER_DISPATCH:

janito/cli/main_cli.py

@@ -38,7 +38,7 @@ definition = [
         },
     ),
     (
-        ["--python"],
+        ["--developer"],
         {
             "action": "store_true",
             "help": "Start with the Python developer profile (equivalent to --profile 'Developer with Python Tools')",
@@ -230,6 +230,10 @@ definition = [
         ["--list-plugins-available"],
         {"action": "store_true", "help": "List all available plugins"},
     ),
+    (
+        ["--list-resources"],
+        {"action": "store_true", "help": "List all resources (tools, commands, config) from loaded plugins"},
+    ),
 ]
 
 MODIFIER_KEYS = [
@@ -237,7 +241,7 @@ MODIFIER_KEYS = [
     "model",
     "role",
     "profile",
-    "python",
+    "developer",
     "market",
     "system",
     "temperature",

janito/cli/single_shot_mode/handler.py

@@ -24,9 +24,9 @@ class PromptHandler:
         self.llm_driver_config = llm_driver_config
         self.role = role
         # Instantiate agent together with prompt handler using the shared helper
-        # Handle --python and --market flags for single shot mode
+        # Handle --developer and --market flags for single shot mode
         profile = getattr(args, "profile", None)
-        if profile is None and getattr(args, "python", False):
+        if profile is None and getattr(args, "developer", False):
             profile = "Developer with Python Tools"
         if profile is None and getattr(args, "market", False):
             profile = "Market Analyst"

janito/config_manager.py

@@ -64,6 +64,14 @@ class ConfigManager:
                 plugin_manager.load_plugins_from_config({"plugins": plugins_config})
             except Exception as e:
                 print(f"Warning: Failed to load plugins from config: {e}")
+        else:
+            # Try loading from user config directory
+            try:
+                from janito.plugins.manager import PluginManager
+                plugin_manager = PluginManager()
+                plugin_manager.load_plugins_from_user_config()
+            except Exception as e:
+                print(f"Warning: Failed to load plugins from user config: {e}")
 
         # Load disabled tools from config - skip during startup to avoid circular imports
         # This will be handled by the CLI when needed

janito/exceptions.py

@@ -9,7 +9,25 @@ class ToolCallException(Exception):
         self.error = error
         self.arguments = arguments
         self.original_exception = exception
-        super().__init__(f"ToolCallException: {tool_name}: {error}")
+        
+        # Build detailed error message
+        details = []
+        details.append(f"ToolCallException: {tool_name}: {error}")
+        
+        if arguments is not None:
+            details.append(f"Arguments received: {arguments}")
+            if isinstance(arguments, dict):
+                details.append("Parameters:")
+                for key, value in arguments.items():
+                    details.append(f"  {key}: {repr(value)} ({type(value).__name__})")
+            elif isinstance(arguments, (list, tuple)):
+                details.append(f"Positional arguments: {arguments}")
+                for i, value in enumerate(arguments):
+                    details.append(f"  [{i}]: {repr(value)} ({type(value).__name__})")
+            else:
+                details.append(f"Single argument: {repr(arguments)} ({type(arguments).__name__})")
+        
+        super().__init__("\n".join(details))
 
 
 class MissingProviderSelectionException(Exception):

janito/plugins/base.py

@@ -4,7 +4,7 @@ Base classes for janito plugins.
 
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import Dict, Any, List, Optional, Type
+from typing import Dict, Any, List, Optional, Type, Union
 from janito.tools.tool_base import ToolBase
 
 
@@ -24,6 +24,15 @@ class PluginMetadata:
             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.
@@ -90,4 +99,46 @@ class Plugin(ABC):
         Returns:
             True if configuration is valid
         """
-        return True
+        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/config.py

@@ -0,0 +1,87 @@
+"""
+Configuration management for plugins using user directory.
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+
+def get_user_config_dir() -> Path:
+    """Get the user configuration directory."""
+    return Path.home() / ".janito"
+
+
+def get_plugins_config_path() -> Path:
+    """Get the path to the plugins configuration file."""
+    return get_user_config_dir() / "plugins.json"
+
+
+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": {}
+            }
+        }
+        
+        # Ensure directory exists
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Save default config
+        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:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError) as e:
+        print(f"Warning: Failed to load plugins config from {config_path}: {e}")
+        return {"plugins": {"paths": [], "load": {}}}
+
+
+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:
+            json.dump(config, f, indent=2)
+        return True
+    except IOError as e:
+        print(f"Error: Failed to save plugins config to {config_path}: {e}")
+        return False
+
+
+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

janito/plugins/discovery.py

@@ -1,5 +1,26 @@
 """
 Plugin discovery utilities.
+
+Plugins can be provided in several formats:
+
+1. Single Python file: A .py file containing a Plugin class
+   Example: plugins/my_plugin.py
+
+2. Python package directory: A directory with __init__.py or plugin.py
+   Example: plugins/my_plugin/__init__.py
+   Example: plugins/my_plugin/plugin.py
+
+3. Installed Python package: An installed package with a Plugin class
+   Example: pip install janito-plugin-example
+
+4. ZIP file: A .zip file containing a Python package structure
+   Example: plugins/my_plugin.zip (containing package structure)
+
+The plugin discovery system searches these locations in order:
+- Current working directory/plugins/
+- ~/.janito/plugins/
+- Python installation share/janito/plugins/
+- Any additional paths specified via configuration
 """
 
 import os
@@ -19,6 +40,12 @@ def discover_plugins(plugin_name: str, search_paths: List[Path] = None) -> Optio
     """
     Discover and load a plugin by name.
     
+    Supports multiple plugin formats:
+    - Single .py files
+    - Python package directories
+    - 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
@@ -126,6 +153,11 @@ 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
+    - Any valid plugin structure in search paths
+    
     Args:
         search_paths: List of directories to search for plugins
         

janito/plugins/manager.py

@@ -12,6 +12,7 @@ import logging
 
 from .base import Plugin, PluginMetadata
 from .discovery import discover_plugins
+from .config import load_plugins_config, get_user_plugins_dir
 from janito.tools.adapters.local import LocalToolsAdapter
 
 logger = logging.getLogger(__name__)
@@ -158,6 +159,14 @@ class PluginManager:
             else:
                 self.load_plugin(plugin_name, plugin_config)
     
+    def load_plugins_from_user_config(self) -> None:
+        """
+        Load plugins from user configuration directory.
+        Uses ~/.janito/plugins.json instead of janito.json
+        """
+        config = load_plugins_config()
+        self.load_plugins_from_config(config)
+    
     def reload_plugin(self, plugin_name: str) -> bool:
         """
         Reload a plugin.
@@ -180,6 +189,51 @@ class PluginManager:
                 'metadata': plugin.metadata,
                 'tools': [tool.__name__ for tool in plugin.get_tools()],
                 'commands': list(plugin.get_commands().keys()),
-                'config': self.plugin_configs.get(name, {})
+                'config': self.plugin_configs.get(name, {}),
+                'resources': [
+                    {
+                        '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
             }
-        return info
+            for resource in plugin.get_resources()
+        ]
+
+    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

janito/tools/adapters/local/adapter.py

@@ -140,18 +140,18 @@ class LocalToolsAdapter(ToolsAdapter):
     def execute_tool(self, name: str, **kwargs):
         """
         Execute a tool with proper error handling.
-        
+
         This method extends the base execute_tool functionality by adding
         error handling for RuntimeError exceptions that may be raised by
         tools with loop protection decorators.
-        
+
         Args:
             name: The name of the tool to execute
             **kwargs: Arguments to pass to the tool
-            
+
         Returns:
             The result of the tool execution
-            
+
         Raises:
             ToolCallException: If tool execution fails for any reason
             ValueError: If the tool is not found or not allowed
@@ -160,30 +160,12 @@ class LocalToolsAdapter(ToolsAdapter):
         tool = self.get_tool(name)
         if not tool:
             raise ValueError(f"Tool '{name}' not found or not allowed.")
-        
+
         # Record tool usage
         self.tool_tracker.record(name, kwargs)
-        
-        # Execute the tool and handle any RuntimeError from loop protection
-        try:
-            return super().execute_tool(name, **kwargs)
-        except RuntimeError as e:
-            # Check if this is a loop protection error
-            if "Loop protection:" in str(e):
-                # Re-raise as ToolCallException to maintain consistent error flow
-                from janito.exceptions import ToolCallException
-                raise ToolCallException(
-                    name, 
-                    f"Loop protection triggered: {str(e)}", 
-                    arguments=kwargs
-                )
-            # Re-raise other RuntimeError exceptions as ToolCallException
-            from janito.exceptions import ToolCallException
-            raise ToolCallException(
-                name, 
-                f"Runtime error during tool execution: {str(e)}", 
-                arguments=kwargs
-            )
+
+        # Execute the tool using execute_by_name which handles loop protection
+        return self.execute_by_name(name, arguments=kwargs)
 
     # ------------------------------------------------------------------
     # Convenience methods

janito/tools/adapters/local/ask_user.py

@@ -32,7 +32,7 @@ class AskUserTool(ToolBase):
     permissions = ToolPermissions(read=True)
     tool_name = "ask_user"
 
-    @protect_against_loops(max_calls=5, time_window=10.0)
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="question")
     def run(self, question: str) -> str:
 
         print()  # Print an empty line before the question panel

janito/tools/adapters/local/copy_file.py

@@ -1,4 +1,5 @@
 import os
+from janito.tools.path_utils import expand_path
 import shutil
 from typing import List, Union
 from janito.tools.adapters.local.adapter import register_local_tool
@@ -26,7 +27,8 @@ class CopyFileTool(ToolBase):
     tool_name = "copy_file"
 
     def run(self, sources: str, target: str, overwrite: bool = False) -> str:
-        source_list = [src for src in sources.split() if src]
+        source_list = [expand_path(src) for src in sources.split() if src]
+        target = expand_path(target)
         messages = []
         if len(source_list) > 1:
             if not os.path.isdir(target):

janito/tools/adapters/local/create_directory.py

@@ -5,6 +5,7 @@ from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
 from janito.i18n import tr
 import os
+from janito.tools.path_utils import expand_path
 
 
 @register_local_tool
@@ -23,8 +24,7 @@ class CreateDirectoryTool(ToolBase):
     tool_name = "create_directory"
 
     def run(self, path: str) -> str:
-        # path = expand_path(path)
-        # Using path as is
+        path = expand_path(path)
         disp_path = display_path(path)
         self.report_action(
             tr("📁 Create directory '{disp_path}' ...", disp_path=disp_path),

janito/tools/adapters/local/create_file.py

@@ -1,11 +1,12 @@
 import os
+from janito.tools.path_utils import expand_path
 from janito.tools.adapters.local.adapter import register_local_tool
 
 from janito.tools.tool_utils import display_path
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
 from janito.i18n import tr
-
+from janito.tools.loop_protection_decorator import protect_against_loops
 
 from janito.tools.adapters.local.validate_file_syntax.core import validate_file_syntax
 
@@ -24,15 +25,18 @@ class CreateFileTool(ToolBase):
             - "✅ Successfully created the file at ..."
 
     Note: Syntax validation is automatically performed after this operation.
+    
+    Security: This tool includes loop protection to prevent excessive file creation operations.
+    Maximum 5 calls per 10 seconds for the same file path.
     """
 
     permissions = ToolPermissions(write=True)
     tool_name = "create_file"
 
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
     def run(self, path: str, content: str, overwrite: bool = False) -> str:
-        expanded_path = path  # Using path as is
-        disp_path = display_path(expanded_path)
-        path = expanded_path
+        path = expand_path(path)
+        disp_path = display_path(path)
         if os.path.exists(path) and not overwrite:
             try:
                 with open(path, "r", encoding="utf-8", errors="replace") as f: