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

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/provider_registry.py

@@ -41,7 +41,7 @@ class ProviderRegistry:
             rows.append(info[:3])
 
         # Group providers by openness (open-source first, then proprietary)
-        open_providers = {"cerebras", "deepseek", "alibaba", "moonshotai", "zai"}
+        open_providers = {"cerebras", "deepseek", "alibaba", "moonshot", "zai"}
 
         def sort_key(row):
             provider_name = row[0]

janito/providers/openai/provider.py

@@ -18,7 +18,7 @@ class OpenAIProvider(LLMProvider):
     MAINTAINER = "João Pinto <janito@ikignosis.org>"
     MODEL_SPECS = MODEL_SPECS
     DEFAULT_MODEL = (
-        "gpt-4.1"  # Options: gpt-4.1, gpt-4o, o3-mini, o4-mini, gpt-5, gpt-5-nano
+        "gpt-5"  # Options: gpt-4.1, gpt-4o, o3-mini, o4-mini, gpt-5, gpt-5-nano
     )
 
     def __init__(

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/search_text/core.py

@@ -98,7 +98,7 @@ class SearchTextTool(ToolBase):
         if max_depth > 0:
             info_str += tr(" [max_depth={max_depth}]", max_depth=max_depth)
         if count_only:
-            info_str += " [count-only]"
+            info_str += " [count]"
         self.report_action(info_str, ReportAction.READ)
         if os.path.isfile(search_path):
             dir_output, dir_limit_reached, per_file_counts = self._handle_file(

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