janito 2.30.0__py3-none-any.whl → 2.31.1__py3-none-any.whl

janito/cli/cli_commands/list_plugins.py

@@ -4,10 +4,15 @@ CLI command to list available and loaded plugins.
 
 import argparse
 from typing import List, Dict, Any
-from janito.plugins.discovery import list_available_plugins, discover_plugins
+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.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
+from rich.text import Text
 
 
 def handle_list_plugins(args: argparse.Namespace) -> None:
@@ -22,19 +27,49 @@ def handle_list_plugins(args: argparse.Namespace) -> None:
 
 
 def _list_available_plugins():
-    """List available plugins."""
+    """List available plugins using rich formatting."""
+    console = Console()
     available = list_available_plugins()
     builtin_plugins = BuiltinPluginRegistry.list_builtin_plugins()
 
     if available or builtin_plugins:
-        print("Available plugins:")
-        _print_builtin_plugins(builtin_plugins)
-        _print_external_plugins(available, builtin_plugins)
+        # Create main table
+        table = Table(title="Available Plugins")
+        table.add_column("Plugin Name", style="cyan", no_wrap=True)
+        table.add_column("Type", style="magenta")
+        table.add_column("Status", style="green")
+
+        # Add builtin plugins
+        for plugin in builtin_plugins:
+            table.add_row(plugin, "Builtin", "📦")
+
+        # Add external plugins
+        other_plugins = [p for p in available if p not in builtin_plugins]
+        for plugin in other_plugins:
+            table.add_row(plugin, "External", "🔌")
+
+        console.print(table)
+
+        # Show 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)
+        core_table.add_column("Status", style="yellow")
+
+        for plugin in core_plugins:
+            core_table.add_row(plugin, "✅ Available")
+
+        console.print(core_table)
     else:
-        print("No plugins found in search paths")
-        print("Search paths:")
-        print(f"  - {os.getcwd()}/plugins")
-        print(f"  - {os.path.expanduser('~')}/.janito/plugins")
+        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):
@@ -55,18 +90,51 @@ def _print_external_plugins(available, builtin_plugins):
 
 
 def _list_plugin_resources():
-    """List all resources from loaded plugins."""
-    manager = PluginManager()
+    """List all resources from loaded plugins using rich formatting."""
+    from janito.plugins.auto_loader_fixed import get_plugin_manager
+    
+    console = Console()
+    manager = get_plugin_manager()
     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'}:")
-            _print_resources_by_type(resources)
+            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"]
+
+            if tools:
+                panel_content.append("[bold blue]Tools:[/bold blue]")
+                for tool in tools:
+                    panel_content.append(f"  • {tool['name']}: {tool['description']}")
+
+            if commands:
+                panel_content.append("[bold green]Commands:[/bold green]")
+                for cmd in commands:
+                    panel_content.append(f"  • {cmd['name']}: {cmd['description']}")
+
+            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"
+            ))
     else:
-        print("No plugins loaded")
+        console.print(Panel(
+            "No plugins are currently loaded.",
+            title="No Plugin Resources",
+            style="yellow"
+        ))
 
 
 def _print_resources_by_type(resources):
@@ -92,16 +160,59 @@ def _print_resources_by_type(resources):
 
 
 def _list_loaded_plugins():
-    """List loaded plugins."""
-    manager = PluginManager()
+    """List loaded plugins using rich formatting."""
+    from janito.plugins.auto_loader_fixed import get_plugin_manager
+    
+    console = Console()
+    manager = get_plugin_manager()
     loaded = manager.list_plugins()
 
     if loaded:
-        print("Loaded plugins:")
+        # Create main table
+        table = Table(title="Loaded Plugins")
+        table.add_column("Plugin Name", style="cyan", no_wrap=True)
+        table.add_column("Version", style="magenta")
+        table.add_column("Description", style="green", max_width=50)
+        table.add_column("Type", style="yellow")
+
+        core_plugins = []
+        other_plugins = []
+        
         for plugin_name in loaded:
-            _print_plugin_details(manager, plugin_name)
+            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"
+                )
+        
+        # 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"
+                )
+
+        console.print(table)
     else:
-        print("No plugins loaded")
+        console.print(Panel(
+            "No plugins are currently loaded.",
+            title="No Plugins Loaded",
+            style="yellow"
+        ))
 
 
 def _print_plugin_details(manager, plugin_name):

janito/cli/rich_terminal_reporter.py

@@ -161,7 +161,7 @@ class RichTerminalReporter(EventHandlerBase):
             self.console.print(msg)
             self.console.file.flush()
         elif subtype == ReportSubtype.STDOUT:
-            self.console.print(Text(msg, style="on dark_green"))
+            self.console.print(msg)
             self.console.file.flush()
         elif subtype == ReportSubtype.STDERR:
             self.console.print(Text(msg, style="on red"))

janito/plugins/auto_loader.py

@@ -0,0 +1,91 @@
+"""
+Auto-loader for core plugins.
+
+This module automatically loads core plugins when the plugin system is initialized.
+"""
+
+import os
+from pathlib import Path
+from typing import List
+from janito.plugins.manager import PluginManager
+from janito.plugins.discovery import list_available_plugins
+
+# List of core plugins that should be enabled by default
+CORE_PLUGINS = [
+    "core.filemanager",
+    "core.codeanalyzer", 
+    "core.system",
+    "core.imagedisplay",
+    "dev.pythondev",
+    "dev.visualization",
+    "ui.userinterface",
+    "web.webtools",
+]
+
+
+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()
+    
+    # Ensure plugins directory is in search path
+    plugins_dir = Path.cwd() / "plugins"
+    if plugins_dir.exists():
+        pm.add_plugin_path(str(plugins_dir))
+    
+    loaded = []
+    
+    # Load core plugins
+    for plugin_name in CORE_PLUGINS:
+        try:
+            if pm.load_plugin(plugin_name):
+                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
+    """
+    pm = PluginManager()
+    loaded = pm.list_plugins()
+    return [p for p in loaded if p in CORE_PLUGINS]
+
+
+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
+    """
+    return plugin_name in CORE_PLUGINS
+
+
+# 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

janito/plugins/auto_loader_fixed.py

@@ -0,0 +1,90 @@
+"""
+Fixed auto-loader for core plugins.
+
+This module provides a working implementation to load core plugins
+without the complex discovery mechanism.
+"""
+
+import os
+from pathlib import Path
+from typing import List
+from janito.plugins.manager import PluginManager
+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.system",
+    "core.imagedisplay",
+    "dev.pythondev",
+    "dev.visualization",
+    "ui.userinterface",
+    "web.webtools",
+]
+
+
+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:
+            plugin = load_core_plugin(plugin_name)
+            if plugin:
+                # Manually register the plugin
+                pm.plugins[plugin_name] = plugin
+                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
+    """
+    pm = PluginManager()
+    loaded = pm.list_plugins()
+    return [p for p in loaded if p in CORE_PLUGINS]
+
+
+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
+    """
+    return plugin_name in CORE_PLUGINS
+
+
+# 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

janito/plugins/core_adapter.py

@@ -0,0 +1,53 @@
+"""
+Core plugin adapter for legacy plugin system.
+
+This module provides proper Plugin class implementations for core plugins
+that use the function-based approach instead of class-based.
+"""
+
+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
+
+
+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,
+            version="1.0.0",
+            description=self._description,
+            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):
+                tool_class = create_function_tool(tool_func)
+                self._tool_classes.append(tool_class)
+
+
+def create_core_plugin(plugin_name: str, description: str, tools_module) -> CorePluginAdapter:
+    """Create a core plugin adapter."""
+    return CorePluginAdapter(plugin_name, description, tools_module)

janito/plugins/core_loader.py

@@ -0,0 +1,120 @@
+"""
+Core plugin loader that properly handles function-based plugins.
+
+This module provides a simplified approach to load core plugins
+without the complex discovery mechanism.
+"""
+
+import importlib.util
+import sys
+from pathlib import Path
+from typing import Optional
+
+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):
+    """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 = []
+        
+    def get_metadata(self) -> PluginMetadata:
+        return PluginMetadata(
+            name=self._plugin_name,
+            version="1.0.0",
+            description=self._description,
+            author="Janito",
+            license="MIT",
+        )
+    
+    def get_tools(self) -> list:
+        return self._tool_classes
+    
+    def initialize(self):
+        """Initialize by creating tool classes."""
+        self._tool_classes = []
+        for tool_func in self._tools:
+            if callable(tool_func):
+                tool_class = create_function_tool(tool_func)
+                self._tool_classes.append(tool_class)
+
+
+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
+    """
+    try:
+        # 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
+        
+        # Build path to plugin
+        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}")
+        tools = getattr(module, "__plugin_tools__", [])
+        
+        if not tools:
+            return None
+            
+        # Create plugin
+        plugin = CorePlugin(name, description, tools)
+        plugin.initialize()
+        return plugin
+        
+    except Exception as e:
+        print(f"Error loading core plugin {plugin_name}: {e}")
+        return None
+
+
+def get_core_plugins() -> list:
+    """Get list of all available core plugins."""
+    core_plugins = [
+        "core.filemanager",
+        "core.codeanalyzer",
+        "core.system",
+        "core.imagedisplay",
+        "dev.pythondev",
+        "dev.visualization",
+        "ui.userinterface",
+        "web.webtools",
+    ]
+    
+    available = []
+    for plugin_name in core_plugins:
+        plugin = load_core_plugin(plugin_name)
+        if plugin:
+            available.append(plugin_name)
+    
+    return available

janito/plugins/core_loader_fixed.py

@@ -0,0 +1,125 @@
+"""
+Fixed core plugin loader.
+
+This module provides a working implementation to load core plugins
+by directly using the Plugin base class properly.
+"""
+
+import importlib.util
+import sys
+from pathlib import Path
+from typing import Optional, List, Type
+
+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."""
+    
+    def __init__(self, name: str, description: str, tools: list):
+        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,
+            version="1.0.0",
+            description=self._description,
+            author="Janito",
+            license="MIT",
+        )
+    
+    def get_tools(self) -> List[Type[ToolBase]]:
+        return self._tool_classes
+    
+    def initialize(self):
+        """Initialize by creating tool classes."""
+        self._tool_classes = []
+        for tool_func in self._tools:
+            if callable(tool_func):
+                tool_class = create_function_tool(tool_func)
+                self._tool_classes.append(tool_class)
+
+
+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
+    """
+    try:
+        # 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:
+                from plugins.core.imagedisplay.plugin import ImageDisplayPlugin
+                return ImageDisplayPlugin()
+            except ImportError:
+                # If import fails, return None - don't return True
+                return None
+        
+        # Build path to plugin
+        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}")
+        tools = getattr(module, "__plugin_tools__", [])
+        
+        if not tools:
+            return None
+            
+        # Create plugin
+        plugin = CorePlugin(name, description, tools)
+        plugin.initialize()
+        return plugin
+        
+    except Exception as e:
+        print(f"Error loading core plugin {plugin_name}: {e}")
+        return None
+
+
+def get_core_plugins() -> list:
+    """Get list of all available core plugins."""
+    core_plugins = [
+        "core.filemanager",
+        "core.codeanalyzer",
+        "core.system",
+        "core.imagedisplay",
+        "dev.pythondev",
+        "dev.visualization",
+        "ui.userinterface",
+        "web.webtools",
+    ]
+    
+    # All core plugins are always available
+    return core_plugins

janito/plugins/discovery.py

@@ -33,6 +33,7 @@ import logging
 
 from .base import Plugin
 from .builtin import load_builtin_plugin, BuiltinPluginRegistry
+from .core_loader import load_core_plugin
 
 logger = logging.getLogger(__name__)
 
@@ -74,6 +75,13 @@ def discover_plugins(
         parts = plugin_name.split(".")
         if len(parts) == 2:
             package_name, submodule_name = parts
+            
+            # Handle core plugins with dedicated loader
+            if plugin_name.startswith(("core.", "dev.", "ui.", "web.")):
+                plugin = load_core_plugin(plugin_name)
+                if plugin:
+                    return plugin
+                    
             for base_path in all_paths:
                 package_path = base_path / package_name / submodule_name / "__init__.py"
                 if package_path.exists():

janito/plugins/discovery_core.py

@@ -0,0 +1,49 @@
+"""
+Core plugin discovery utilities.
+
+This module provides specialized handling for core plugins that use
+the function-based approach instead of class-based plugins.
+"""
+
+import importlib.util
+from pathlib import Path
+from typing import Optional
+import sys
+
+from .base import Plugin
+from .core_adapter import CorePluginAdapter
+
+
+def _load_core_plugin(package_path: Path, plugin_name: str) -> Optional[Plugin]:
+    """
+    Load a core plugin from a package directory.
+    
+    Args:
+        package_path: Path to the __init__.py file
+        plugin_name: Full plugin name (e.g., core.filemanager)
+        
+    Returns:
+        Plugin instance if loaded successfully
+    """
+    try:
+        # Import the module
+        spec = importlib.util.spec_from_file_location(plugin_name, package_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 metadata
+        plugin_name_attr = getattr(module, "__plugin_name__", plugin_name)
+        description = getattr(module, "__plugin_description__", f"Core plugin: {plugin_name}")
+        
+        # Create and return the core plugin adapter
+        plugin = CorePluginAdapter(plugin_name_attr, description, module)
+        plugin.initialize()  # Initialize to set up tools
+        return plugin
+        
+    except Exception as e:
+        import logging
+        logging.getLogger(__name__).error(f"Failed to load core plugin {plugin_name}: {e}")
+        return None

janito/tools/adapters/local/__init__.py

@@ -24,6 +24,8 @@ from .get_file_outline.search_outline import SearchOutlineTool
 from .search_text.core import SearchTextTool
 from .validate_file_syntax.core import ValidateFileSyntaxTool
 from .read_chart import ReadChartTool
+from .show_image import ShowImageTool
+from .show_image_grid import ShowImageGridTool
 
 from janito.tools.tool_base import ToolPermissions
 import os
@@ -63,6 +65,8 @@ for tool_class in [
     SearchTextTool,
     ValidateFileSyntaxTool,
     ReadChartTool,
+    ShowImageTool,
+    ShowImageGridTool,
 ]:
     local_tools_adapter.register_tool(tool_class)
 

janito/tools/adapters/local/create_file.py

@@ -14,20 +14,71 @@ from janito.tools.adapters.local.validate_file_syntax.core import validate_file_
 @register_local_tool
 class CreateFileTool(ToolBase):
     """
-    Create a new file with the given content.
+    Create a new file with specified content at the given path.
+
+    This tool provides comprehensive file creation capabilities with built-in safety features,
+    automatic syntax validation, and detailed feedback. It handles path expansion, directory
+    creation, encoding issues, and provides clear status messages for both success and failure cases.
+
+    Key Features:
+    - Automatic directory creation for nested paths
+    - UTF-8 encoding with error handling for special characters
+    - Built-in syntax validation for common file types (Python, JavaScript, JSON, YAML, etc.)
+    - Loop protection to prevent excessive file creation
+    - Detailed error messages with context
+    - Safe overwrite protection with preview of existing content
+    - Cross-platform path handling (Windows, macOS, Linux)
 
     Args:
-        path (str): Path to the file to create.
-        content (str): Content to write to the file.
-        overwrite (bool, optional): Overwrite existing file if True. Default: False. Recommended only after reading the file to be overwritten.
+        path (str): Target file path. Supports relative and absolute paths, with automatic
+                   expansion of user home directory (~) and environment variables.
+                   Examples: "src/main.py", "~/Documents/config.json", "$HOME/.env"
+        content (str): File content to write. Empty string creates empty file.
+                      Supports any text content including Unicode characters, newlines,
+                      and binary-safe text representation.
+        overwrite (bool, optional): If True, allows overwriting existing files. Default: False.
+                                   When False, prevents accidental overwrites by checking
+                                   file existence and showing current content. Always review
+                                   existing content before enabling overwrite.
+
     Returns:
-        str: Status message indicating the result. Example:
-            - "✅ Successfully created the file at ..."
+        str: Detailed status message including:
+            - Success confirmation with line count
+            - File path (display-friendly format)
+            - Syntax validation results
+            - Existing content preview (when overwrite blocked)
+            - Error details (when creation fails)
+
+    Raises:
+        No direct exceptions - all errors are caught and returned as user-friendly messages.
+        Common error cases include: permission denied, invalid path format, disk full,
+        or file exists (when overwrite=False).
+
+    Security Features:
+        - Loop protection: Maximum 5 calls per 10 seconds for the same file path
+        - Path traversal prevention: Validates and sanitizes file paths
+        - Permission checking: Respects file system permissions
+        - Atomic writes: Prevents partial file creation on errors
+
+    Examples:
+        Basic file creation:
+        >>> create_file("hello.py", "print('Hello, World!')")
+        ✅ Created file 1 lines.
+        ✅ Syntax OK
+
+        Creating nested directories:
+        >>> create_file("src/utils/helpers.py", "def helper(): pass")
+        ✅ Created file 2 lines.
+        ✅ Syntax OK
 
-    Note: Syntax validation is automatically performed after this operation.
+        Overwrite protection:
+        >>> create_file("existing.txt", "new content")
+        ❗ Cannot create file: file already exists at 'existing.txt'.
+        --- Current file content ---
+        old content
 
-    Security: This tool includes loop protection to prevent excessive file creation operations.
-    Maximum 5 calls per 10 seconds for the same file path.
+    Note: After successful creation, automatic syntax validation is performed based on
+    file extension. Results are appended to the return message for immediate feedback.
     """
 
     permissions = ToolPermissions(write=True)

janito/tools/adapters/local/fetch_url.py

@@ -246,10 +246,35 @@ class FetchUrlTool(ToolBase):
             return content
         except requests.exceptions.HTTPError as http_err:
             status_code = http_err.response.status_code if http_err.response else None
+            
+            # Map status codes to descriptions
+            status_descriptions = {
+                400: "Bad Request",
+                401: "Unauthorized", 
+                403: "Forbidden",
+                404: "Not Found",
+                405: "Method Not Allowed",
+                408: "Request Timeout",
+                409: "Conflict",
+                410: "Gone",
+                413: "Payload Too Large",
+                414: "URI Too Long",
+                415: "Unsupported Media Type",
+                429: "Too Many Requests",
+                500: "Internal Server Error",
+                501: "Not Implemented",
+                502: "Bad Gateway",
+                503: "Service Unavailable",
+                504: "Gateway Timeout",
+                505: "HTTP Version Not Supported"
+            }
+            
             if status_code and 400 <= status_code < 500:
+                description = status_descriptions.get(status_code, "Client Error")
                 error_message = tr(
-                    "HTTP {status_code}",
+                    "HTTP Error {status_code} {description}",
                     status_code=status_code,
+                    description=description,
                 )
                 # Cache 403 and 404 errors
                 if status_code in [403, 404]:
@@ -257,23 +282,27 @@ class FetchUrlTool(ToolBase):
 
                 self.report_error(
                     tr(
-                        "❗ HTTP {status_code}",
+                        "❗ HTTP Error {status_code} {description}",
                         status_code=status_code,
+                        description=description,
                     ),
                     ReportAction.READ,
                 )
                 return error_message
             else:
+                description = status_descriptions.get(status_code, "Server Error") if status_code else "Error"
                 self.report_error(
                     tr(
-                        "❗ HTTP {status_code}",
+                        "❗ HTTP Error {status_code} {description}",
                         status_code=status_code or "Error",
+                        description=description,
                     ),
                     ReportAction.READ,
                 )
                 return tr(
-                    "HTTP {status_code}",
+                    "HTTP Error {status_code} {description}",
                     status_code=status_code or "Error",
+                    description=description,
                 )
         except Exception as err:
             self.report_error(
@@ -355,7 +384,7 @@ class FetchUrlTool(ToolBase):
                 follow_redirects=follow_redirects,
             )
             if (
-                html_content.startswith("HTTP ")
+                html_content.startswith("HTTP Error ")
                 or html_content == "Error"
                 or html_content == "Blocked"
             ):
@@ -388,7 +417,7 @@ class FetchUrlTool(ToolBase):
             follow_redirects=follow_redirects,
         )
         if (
-            html_content.startswith("HTTP ")
+            html_content.startswith("HTTP Error ")
             or html_content == "Error"
             or html_content == "Blocked"
         ):

janito/tools/adapters/local/show_image.py

@@ -0,0 +1,70 @@
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.i18n import tr
+from janito.tools.loop_protection_decorator import protect_against_loops
+
+
+@register_local_tool
+class ShowImageTool(ToolBase):
+    """Display an image inline in the terminal using the rich library.
+
+    Args:
+        path (str): Path to the image file.
+        width (int, optional): Target width in terminal cells. If unset, auto-fit.
+        height (int, optional): Target height in terminal rows. If unset, auto-fit.
+        preserve_aspect (bool, optional): Preserve aspect ratio. Default: True.
+
+    Returns:
+        str: Status message indicating display result or error details.
+    """
+
+    permissions = ToolPermissions(read=True)
+    tool_name = "show_image"
+
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
+    def run(
+        self,
+        path: str,
+        width: int | None = None,
+        height: int | None = None,
+        preserve_aspect: bool = True,
+    ) -> str:
+        from janito.tools.tool_utils import display_path
+        from janito.tools.path_utils import expand_path
+        import os
+
+        try:
+            from rich.console import Console
+            from rich.image import Image as RichImage
+        except Exception as e:
+            msg = tr("⚠️ Missing dependency: rich ({error})", error=e)
+            self.report_error(msg)
+            return msg
+
+        path = expand_path(path)
+        disp_path = display_path(path)
+        self.report_action(tr("🖼️ Show image '{disp_path}'", disp_path=disp_path), ReportAction.READ)
+
+        if not os.path.exists(path):
+            msg = tr("❗ not found")
+            self.report_warning(msg)
+            return tr("Error: file not found: {path}", path=disp_path)
+
+        try:
+            console = Console()
+            img = RichImage.from_path(path, width=width, height=height, preserve_aspect_ratio=preserve_aspect)
+            console.print(img)
+            self.report_success(tr("✅ Displayed"))
+            details = []
+            if width:
+                details.append(f"width={width}")
+            if height:
+                details.append(f"height={height}")
+            if not preserve_aspect:
+                details.append("preserve_aspect=False")
+            info = ("; ".join(details)) if details else "auto-fit"
+            return tr("Image displayed: {disp_path} ({info})", disp_path=disp_path, info=info)
+        except Exception as e:
+            self.report_error(tr(" ❌ Error: {error}", error=e))
+            return tr("Error displaying image: {error}", error=e)

janito/tools/adapters/local/show_image_grid.py

@@ -0,0 +1,75 @@
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.i18n import tr
+from janito.tools.loop_protection_decorator import protect_against_loops
+from typing import Sequence
+
+
+@register_local_tool
+class ShowImageGridTool(ToolBase):
+    """Display multiple images in a grid inline in the terminal using rich.
+
+    Args:
+        paths (list[str]): List of image file paths.
+        columns (int, optional): Number of columns in the grid. Default: 2.
+        width (int, optional): Max width for each image cell. Default: None (auto).
+        height (int, optional): Max height for each image cell. Default: None (auto).
+        preserve_aspect (bool, optional): Preserve aspect ratio. Default: True.
+
+    Returns:
+        str: Status string summarizing the grid display.
+    """
+
+    permissions = ToolPermissions(read=True)
+    tool_name = "show_image_grid"
+
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="paths")
+    def run(
+        self,
+        paths: Sequence[str],
+        columns: int = 2,
+        width: int | None = None,
+        height: int | None = None,
+        preserve_aspect: bool = True,
+    ) -> str:
+        from janito.tools.path_utils import expand_path
+        from janito.tools.tool_utils import display_path
+        import os
+
+        try:
+            from rich.console import Console
+            from rich.columns import Columns
+            from rich.image import Image as RichImage
+            from rich.panel import Panel
+        except Exception as e:
+            msg = tr("⚠️ Missing dependency: rich ({error})", error=e)
+            self.report_error(msg)
+            return msg
+
+        if not paths:
+            return tr("No images provided")
+
+        self.report_action(tr("🖼️ Show image grid ({n} images)", n=len(paths)), ReportAction.READ)
+
+        console = Console()
+        images = []
+        shown = 0
+        for p in paths:
+            fp = expand_path(p)
+            if not os.path.exists(fp):
+                self.report_warning(tr("❗ not found: {p}", p=display_path(fp)))
+                continue
+            try:
+                img = RichImage.from_path(fp, width=width, height=height, preserve_aspect_ratio=preserve_aspect)
+                images.append(Panel.fit(img, title=display_path(fp), border_style="dim"))
+                shown += 1
+            except Exception as e:
+                self.report_warning(tr("⚠️ Skipped {p}: {e}", p=display_path(fp), e=e))
+
+        if not images:
+            return tr("No images could be displayed")
+
+        console.print(Columns(images, equal=True, expand=True, columns=columns))
+        self.report_success(tr("✅ Displayed {n} images", n=shown))
+        return tr("Displayed {shown}/{total} images in a {cols}x? grid", shown=shown, total=len(paths), cols=columns)

janito/tools/function_adapter.py

@@ -0,0 +1,65 @@
+"""
+Function-to-Tool adapter for core plugins.
+
+This module provides a way to wrap function-based tools into proper ToolBase classes.
+"""
+
+import inspect
+from typing import Any, Dict, List, Optional, get_type_hints
+from janito.tools.tool_base import ToolBase, ToolPermissions
+
+
+class FunctionToolAdapter(ToolBase):
+    """Adapter that wraps a function into a ToolBase class."""
+    
+    def __init__(self, func, tool_name: str = None, description: str = None):
+        super().__init__()
+        self._func = func
+        self.tool_name = tool_name or func.__name__
+        self._description = description or func.__doc__ or f"Tool: {self.tool_name}"
+        self.permissions = ToolPermissions(read=True, write=True, execute=True)
+        
+    def run(self, **kwargs) -> Any:
+        """Execute the wrapped function."""
+        return self._func(**kwargs)
+    
+    def get_signature(self) -> Dict[str, Any]:
+        """Get function signature for documentation."""
+        sig = inspect.signature(self._func)
+        type_hints = get_type_hints(self._func)
+        
+        params = {}
+        for name, param in sig.parameters.items():
+            param_info = {
+                "type": str(type_hints.get(name, Any)),
+                "default": param.default if param.default != inspect.Parameter.empty else None,
+                "required": param.default == inspect.Parameter.empty,
+            }
+            params[name] = param_info
+            
+        return {
+            "name": self.tool_name,
+            "description": self._description,
+            "parameters": params,
+            "return_type": str(type_hints.get("return", Any))
+        }
+
+
+def create_function_tool(func, tool_name: str = None, description: str = None) -> type:
+    """
+    Create a ToolBase class from a function.
+    
+    Args:
+        func: The function to wrap
+        tool_name: Optional custom tool name
+        description: Optional custom description
+        
+    Returns:
+        A ToolBase subclass that wraps the function
+    """
+    
+    class DynamicFunctionTool(FunctionToolAdapter):
+        def __init__(self):
+            super().__init__(func, tool_name, description)
+    
+    return DynamicFunctionTool

{janito-2.30.0.dist-info → janito-2.31.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 2.30.0
+Version: 2.31.1
 Summary: A new Python package called janito.
 Author-email: João Pinto <janito@ikignosis.org>
 Project-URL: Homepage, https://github.com/ikignosis/janito
@@ -19,6 +19,7 @@ Requires-Dist: requests>=2.32.4
 Requires-Dist: bs4>=0.0.2
 Requires-Dist: questionary>=2.0.1
 Requires-Dist: openai>=1.68.0
+Requires-Dist: Pillow>=10.0.0
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"

{janito-2.30.0.dist-info → janito-2.31.1.dist-info}/RECORD

@@ -33,7 +33,7 @@ janito/cli/main_cli.py,sha256=FXpoybaEbDRlK5-oMOMlcdM7TpVfnOdr6-mOkgJHeTo,16648
 janito/cli/prompt_core.py,sha256=F68J4Xl6jZMYFN4oBBYZFj15Jp-HTYoLub4bw2XpNRU,11648
 janito/cli/prompt_handler.py,sha256=SnPTlL64noeAMGlI08VBDD5IDD8jlVMIYA4-fS8zVLg,215
 janito/cli/prompt_setup.py,sha256=s48gvNfZhKjsEhf4EzL1tKIGm4wDidPMDvlM6TAPYes,2116
-janito/cli/rich_terminal_reporter.py,sha256=K48Ywwj6xz_NikuezzBmYJM1PANmQD-G48sE4NjQhn0,6835
+janito/cli/rich_terminal_reporter.py,sha256=Hitf5U13gncad4GPVAcDMfdSwlfzQzOn9KdeX4TjTWU,6806
 janito/cli/utils.py,sha256=plCQiDKIf3V8mFhhX5H9-MF2W86i-xRdWf8Xi117Z0w,677
 janito/cli/verbose_output.py,sha256=wY_B4of5e8Vv7w1fRwOZzNGU2JqbMdcFnGjtEr4hLus,7686
 janito/cli/chat_mode/bindings.py,sha256=odjc5_-YW1t2FRhBUNRNoBMoQIg5sMz3ktV7xG0ADFU,975
@@ -81,7 +81,7 @@ janito/cli/cli_commands/enable_disable_plugin.py,sha256=IIEg5Gz2aAW_7BKrMQTXSGF0
 janito/cli/cli_commands/list_config.py,sha256=oiQEGaGPjwjG-PrOcakpNMbbqISTsBEs7rkGH3ceQsI,1179
 janito/cli/cli_commands/list_drivers.py,sha256=r2ENykUcvf_9XYp6LHd3RvLXGXyVUA6oe_Pr0dyv92I,5124
 janito/cli/cli_commands/list_models.py,sha256=QF3Wa7OhNcJFKeBxaw0C_rDfsvJFNb-siz5uorajBvo,1595
-janito/cli/cli_commands/list_plugins.py,sha256=lha2XX7AKIGtFattATpJgsEKRSxRULPHXI1vNSQiQcg,3846
+janito/cli/cli_commands/list_plugins.py,sha256=Lv-M6EAFiqnj0tl9Bq23s162t--81AIs2EqZxhi81lQ,7996
 janito/cli/cli_commands/list_profiles.py,sha256=O4k6U9iCEeNH3lM-NP_XX_E9W0h__hheLSn23241dkA,3538
 janito/cli/cli_commands/list_providers.py,sha256=oilrBjNL5mot1nz45XQQY6oeiSxoNvphhQYspNcEJpw,391
 janito/cli/cli_commands/list_providers_region.py,sha256=qrMj_gtgEMty8UH0P_O5SgWCVJ9ZKxGUp_GdsE4_EH4,2548
@@ -132,10 +132,16 @@ janito/llm/message_parts.py,sha256=QY_0kDjaxdoErDgKPRPv1dNkkYJuXIBmHWNLiOEKAH4,1
 janito/llm/model.py,sha256=EioBkdgn8hJ0iQaKN-0KbXlsrk3YKmwR9IbvoEbdVTE,1159
 janito/llm/provider.py,sha256=3FbhQPrWBSEoIdIi-5DWIh0DD_CM570EFf1NcuGyGko,7961
 janito/plugins/__init__.py,sha256=6tTpUDNJJCRqlGK6RBd40wP_xEowuZZh0FRGeQ5lQQA,400
+janito/plugins/auto_loader.py,sha256=8DRpPZtAUtP-et4Lzaam93MH4s_sqQXXKI8Ly5-GQf8,2329
+janito/plugins/auto_loader_fixed.py,sha256=11pL7J0bX3XOOevQa10_oUtNbH-CXkpKhxOl69Bmzro,2335
 janito/plugins/base.py,sha256=4sQdTOogtDgmLWgA3q1Z8h8s-JySRkk9nSAmg0mHoNM,4285
 janito/plugins/builtin.py,sha256=rAdOz5cekFfsTfXJd5-2AXW4Nh81JoBMONqj1skiTR8,2985
 janito/plugins/config.py,sha256=ex5f1XsKPEgIO4DgJCohPzMKAQoUdx1OdSVU0FlSr5o,2331
-janito/plugins/discovery.py,sha256=cs2wlN-7HxH_w8ZcDpmwYQ2tAKUqxm-zzl4cIRYTO-g,9777
+janito/plugins/core_adapter.py,sha256=zOhRMLIsqPb5r-8-pJGucEiWEB1_M5btW6TmsAm-mdE,1877
+janito/plugins/core_loader.py,sha256=VcIwuKUaR2bvRZIFEiUHaS8YulTOKrYtvO_VhKHRpGI,3576
+janito/plugins/core_loader_fixed.py,sha256=ZjBOU-aQCMnRXxQfFSI5caUR_IqaI0HdqOJSt-G-Lkc,3909
+janito/plugins/discovery.py,sha256=JKaoROD4Ci-k8HN1hns130mXq28ZZhQsWfTBSJoOqYc,10106
+janito/plugins/discovery_core.py,sha256=O5OccNWNyrSXGeeTk5xSG0qbsjNsajclNNCiHljFRpI,1613
 janito/plugins/manager.py,sha256=OyqGiZubcPgogs2u_rIV2cs_r4HNPwFZH9U25Z9g5cI,8135
 janito/providers/__init__.py,sha256=EvOFeiqucAY9tgCosJ81p0QA6wQwMT1cR3EeIGrhSQQ,528
 janito/providers/dashscope.bak.zip,sha256=BwXxRmZreEivvRtmqbr5BR62IFVlNjAf4y6DrF2BVJo,5998
@@ -183,6 +189,7 @@ janito/tools/README.md,sha256=5HkLpF5k4PENJER7SlDPRXj0yo9mpHvAHW4uuzhq4ak,115
 janito/tools/__init__.py,sha256=W1B39PztC2UF7PS2WyLH6el32MFOETMlN1-LurOROCg,1171
 janito/tools/base.py,sha256=R38A9xWYh3JRYZMDSom2d1taNDy9J7HpLbZo9X2wH_o,316
 janito/tools/disabled_tools.py,sha256=Tx__16wtMWZ9z34cYLdH1gukwot5MCL-9kLjd5MPX6Y,2110
+janito/tools/function_adapter.py,sha256=A_-5pA5Y3v0TAYMA-vq3A-Cawg75kH5XWcUEkNHSOoI,2267
 janito/tools/inspect_registry.py,sha256=Jo7PrMPRKLuR-j_mBAk9PBcTzeJf1eQrS1ChGofgQk0,538
 janito/tools/loop_protection.py,sha256=WQ2Cqt459vXvrO0T1EqkEHynHlRkPzfaC83RSmXzjkM,4718
 janito/tools/loop_protection_decorator.py,sha256=R1j2ouscKbVcDm2wlxRZ6zQuKExgj633ijeDq4j0oO0,6457
@@ -200,14 +207,14 @@ janito/tools/tools_adapter.py,sha256=F1Wkji222dY53HMaZWf3vqVas1Bimm3UXERKvxF54Ew
 janito/tools/tools_schema.py,sha256=rGrKrmpPNR07VXHAJ_haGBRRO-YGLOF51BlYRep9AAQ,4415
 janito/tools/url_whitelist.py,sha256=0CPLkHTp5HgnwgjxwgXnJmwPeZQ30q4j3YjW59hiUUE,4295
 janito/tools/adapters/__init__.py,sha256=XKixOKtUJs1R-rGwGDXSLVLg5-Kp090gvWbsseWT4LI,92
-janito/tools/adapters/local/__init__.py,sha256=8xJw8Qv3T_wwkiGBVVgs9p7pH1ONIAipccEUqY2II8A,2231
+janito/tools/adapters/local/__init__.py,sha256=I6LtLnDTyApZrSlKcihSQqZv3gADVX781Mcj46LH7ac,2362
 janito/tools/adapters/local/adapter.py,sha256=u4nLHTaYdwZXMi1J8lsKvlG6rOmdq9xjey_3zeyCG4k,8707
 janito/tools/adapters/local/ask_user.py,sha256=-shjMRKrRe7HNHM2w_6YAl7eEgl8QXaIV6LKrUDEBxU,4060
 janito/tools/adapters/local/copy_file.py,sha256=SBJm19Ipe5dqRE1Mxl6JSrn4bNmfObVnDr5b1mcEu6c,3682
 janito/tools/adapters/local/create_directory.py,sha256=LxwqQEsnOrEphCIoaMRRx9P9bu0MzidP3Fc5q6letxc,2584
-janito/tools/adapters/local/create_file.py,sha256=nZf8iPScO9_nrvmHwXqOcqpLZkLABTh9uLVNddC4PCk,3760
+janito/tools/adapters/local/create_file.py,sha256=fLTVnMpDnHzzIVK3nS0DtawBT-I18Is-qa0Hg8y6TXY,6385
 janito/tools/adapters/local/delete_text_in_file.py,sha256=uEeedRxXAR7_CqUc_qhbEdM0OzRi_pgnP-iDjs2Zvjk,5087
-janito/tools/adapters/local/fetch_url.py,sha256=bkrFFE41h8pWepqnFpmsJ1gF0oDDd5htBsEwFniSKMQ,16064
+janito/tools/adapters/local/fetch_url.py,sha256=y_KL85y01VxOSPBBr9kQqJiPH3QNFnd248kVYfVKL0g,17401
 janito/tools/adapters/local/find_files.py,sha256=Zbag3aP34vc7ffJh8bOqAwXj3KiZhV--uzTVHtNb-fI,6250
 janito/tools/adapters/local/move_file.py,sha256=LMGm8bn3NNyIPJG4vrlO09smXQcgzA09EwoooZxkIA8,4695
 janito/tools/adapters/local/open_html_in_browser.py,sha256=XqICIwVx5vEE77gHkaNAC-bAeEEy0DBmDksATiL-sRY,2101
@@ -222,6 +229,8 @@ janito/tools/adapters/local/remove_file.py,sha256=Imra4jGkBfAd6pnUAmbUsjN0exj2vz
 janito/tools/adapters/local/replace_text_in_file.py,sha256=zJIDecviF2YRpWxbvhtka4Iaje-QYhcaqQX1PxWolzE,10966
 janito/tools/adapters/local/run_bash_command.py,sha256=7fABqAeAu7WJwzzwHmT54_m5OSwPMcgpQ74lQhPG7TA,7955
 janito/tools/adapters/local/run_powershell_command.py,sha256=uQSJVQe40wSGbesyvZxDmIKJthAbDJFaxXm1dEN3gBs,9313
+janito/tools/adapters/local/show_image.py,sha256=CsWUyLuIrKnTmzG7hw79If40U3ka_VP_jalC2Nu5VPw,2785
+janito/tools/adapters/local/show_image_grid.py,sha256=uPtPaVnyJDjbouGmMsv9AUAsD0NQ9SL4MVnDuyrUOwo,2999
 janito/tools/adapters/local/view_file.py,sha256=cBKcbwbfH-UMyvQ7PmYTgsshcFmorjWtyH1kaYi7oNY,7379
 janito/tools/adapters/local/get_file_outline/__init__.py,sha256=OKV_BHnoD9h-vkcVoW6AHmsuDjjauHPCKNK0nVFl4sU,37
 janito/tools/adapters/local/get_file_outline/core.py,sha256=25k6a8PaDYxAfxnEAvZvOWg2BgUcgKU_BkzJmZKUMEA,4611
@@ -246,9 +255,9 @@ janito/tools/adapters/local/validate_file_syntax/ps1_validator.py,sha256=TeIkPt0
 janito/tools/adapters/local/validate_file_syntax/python_validator.py,sha256=BfCO_K18qy92m-2ZVvHsbEU5e11OPo1pO9Vz4G4616E,130
 janito/tools/adapters/local/validate_file_syntax/xml_validator.py,sha256=AijlsP_PgNuC8ZbGsC5vOTt3Jur76otQzkd_7qR0QFY,284
 janito/tools/adapters/local/validate_file_syntax/yaml_validator.py,sha256=TgyI0HRL6ug_gBcWEm5TGJJuA4E34ZXcIzMpAbv3oJs,155
-janito-2.30.0.dist-info/licenses/LICENSE,sha256=dXV4fOF2ZErugtN8l_Nrj5tsRTYgtjE3cgiya0UfBio,11356
-janito-2.30.0.dist-info/METADATA,sha256=j6bJNIIHZWxOkwjq2a_7ChXefB2RRskuGazhxMByAvI,2282
-janito-2.30.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-janito-2.30.0.dist-info/entry_points.txt,sha256=wIo5zZxbmu4fC-ZMrsKD0T0vq7IqkOOLYhrqRGypkx4,48
-janito-2.30.0.dist-info/top_level.txt,sha256=m0NaVCq0-ivxbazE2-ND0EA9Hmuijj_OGkmCbnBcCig,7
-janito-2.30.0.dist-info/RECORD,,
+janito-2.31.1.dist-info/licenses/LICENSE,sha256=dXV4fOF2ZErugtN8l_Nrj5tsRTYgtjE3cgiya0UfBio,11356
+janito-2.31.1.dist-info/METADATA,sha256=BycR-X5ENC7IszTvyQZnUOdwDPGeaqKx1-znJ6F__Hk,2313
+janito-2.31.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+janito-2.31.1.dist-info/entry_points.txt,sha256=wIo5zZxbmu4fC-ZMrsKD0T0vq7IqkOOLYhrqRGypkx4,48
+janito-2.31.1.dist-info/top_level.txt,sha256=m0NaVCq0-ivxbazE2-ND0EA9Hmuijj_OGkmCbnBcCig,7
+janito-2.31.1.dist-info/RECORD,,