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

janito/{plugins_backup_20250825_070018/tools → tools/adapters/local}/show_image.py

@@ -1,12 +1,12 @@
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
-from janito.plugins.tools.decorators import register_core_tool
+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_core_tool
-class ShowImage(ToolBase):
+@register_local_tool
+class ShowImageTool(ToolBase):
     """Display an image inline in the terminal using the rich library.
 
     Args:
@@ -44,9 +44,7 @@ class ShowImage(ToolBase):
 
         path = expand_path(path)
         disp_path = display_path(path)
-        self.report_action(
-            tr("🖼️ Show image '{disp_path}'", disp_path=disp_path), ReportAction.READ
-        )
+        self.report_action(tr("🖼️ Show image '{disp_path}'", disp_path=disp_path), ReportAction.READ)
 
         if not os.path.exists(path):
             msg = tr("❗ not found")
@@ -57,14 +55,9 @@ class ShowImage(ToolBase):
             console = Console()
             from rich.console import Console
             from rich.text import Text
-
             console = Console()
             img = PILImage.open(path)
-            console.print(
-                Text(
-                    f"Image: {disp_path} ({img.width}x{img.height})", style="bold green"
-                )
-            )
+            console.print(Text(f"Image: {disp_path} ({img.width}x{img.height})", style="bold green"))
             console.print(img)
             self.report_success(tr("✅ Displayed"))
             details = []
@@ -75,9 +68,7 @@ class ShowImage(ToolBase):
             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
-            )
+            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/{plugins/core/imagedisplay/tools → tools/adapters/local}/show_image_grid.py

@@ -1,10 +1,12 @@
 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.
 
@@ -48,9 +50,7 @@ class ShowImageGridTool(ToolBase):
         if not paths:
             return tr("No images provided")
 
-        self.report_action(
-            tr("🖼️ Show image grid ({n} images)", n=len(paths)), ReportAction.READ
-        )
+        self.report_action(tr("🖼️ Show image grid ({n} images)", n=len(paths)), ReportAction.READ)
 
         console = Console()
         images = []
@@ -63,9 +63,7 @@ class ShowImageGridTool(ToolBase):
             try:
                 img = PILImage.open(fp)
                 title = f"{display_path(fp)} ({img.width}x{img.height})"
-                images.append(
-                    Panel.fit(title, title=display_path(fp), border_style="dim")
-                )
+                images.append(Panel.fit(title, 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))
@@ -73,12 +71,6 @@ class ShowImageGridTool(ToolBase):
         if not images:
             return tr("No images could be displayed")
 
-        # Render in columns (grid-like)
         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,
-        )
+        return tr("Displayed {shown}/{total} images in a {cols}x? grid", shown=shown, total=len(paths), cols=columns)

janito/tools/base.py

@@ -1,35 +1,5 @@
 class BaseTool:
-    """
-    Base class for all tools.
-    
-    Parameters:
-        path (str): Target file path for file operations
-        content (str): File content to write or process
-        overwrite (bool): Whether to overwrite existing files (default: False)
-        sources (str): Source file(s) to copy from
-        target (str): Destination path for copy operations
-        recursive (bool): Whether to process directories recursively
-        from_line (int): Starting line number for file reading
-        to_line (int): Ending line number for file reading
-        search_text (str): Text to search for in files
-        replacement_text (str): Text to replace search matches with
-        use_regex (bool): Whether to treat search as regex pattern
-        case_sensitive (bool): Whether search should be case sensitive
-        max_depth (int): Maximum directory depth to search
-        include_gitignored (bool): Whether to include .gitignored files
-        timeout (int): Timeout in seconds for operations
-        require_confirmation (bool): Whether to require user confirmation
-        data (dict): Chart data for visualization tools
-        title (str): Chart title
-        width (int): Chart width in pixels
-        height (int): Chart height in pixels
-        query (str): Search query for text search
-        paths (str): Directory or file paths to search in
-        src_path (str): Source path for move operations
-        dest_path (str): Destination path for move operations
-        code (str): Python code to execute
-        pattern (str): File pattern to match (e.g., '*.py')
-    """
+    """Base class for all tools."""
 
     tool_name: str = ""
 

janito/tools/function_adapter.py

@@ -10,167 +10,56 @@ from janito.tools.tool_base import ToolBase, ToolPermissions
 
 
 class FunctionToolAdapter(ToolBase):
-    """
-    Adapter that wraps a function into a ToolBase class.
-    
-    This adapter provides a unified interface for function-based tools by wrapping
-    individual functions with the ToolBase protocol. It handles parameter mapping
-    and validation automatically.
+    """Adapter that wraps a function into a ToolBase class."""
     
-    Parameters:
-        path (str): Target file path for file operations
-        content (str): File content to write or process
-        overwrite (bool): Whether to overwrite existing files (default: False)
-        sources (str): Source file(s) to copy from
-        target (str): Destination path for copy operations
-        recursive (bool): Whether to process directories recursively
-        from_line (int): Starting line number for file reading
-        to_line (int): Ending line number for file reading
-        search_text (str): Text to search for in files
-        replacement_text (str): Text to replace search matches with
-        use_regex (bool): Whether to treat search as regex pattern
-        case_sensitive (bool): Whether search should be case sensitive
-        max_depth (int): Maximum directory depth to search
-        include_gitignored (bool): Whether to include .gitignored files
-        timeout (int): Timeout in seconds for operations
-        require_confirmation (bool): Whether to require user confirmation
-        data (dict): Chart data for visualization tools
-        title (str): Chart title
-        width (int): Chart width in pixels
-        height (int): Chart height in pixels
-        query (str): Search query for text search
-        paths (str): Directory or file paths to search in
-        src_path (str): Source path for move operations
-        dest_path (str): Destination path for move operations
-        code (str): Python code to execute
-        pattern (str): File pattern to match (e.g., '*.py')
-    """
-
     def __init__(self, func, tool_name: str = None, description: str = None):
         super().__init__()
         self._func = func
-        self.tool_name = tool_name or getattr(func, "tool_name", func.__name__)
+        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,
-        path: str = None,
-        content: str = None,
-        overwrite: bool = None,
-        sources: str = None,
-        target: str = None,
-        recursive: bool = None,
-        from_line: int = None,
-        to_line: int = None,
-        search_text: str = None,
-        replacement_text: str = None,
-        use_regex: bool = None,
-        case_sensitive: bool = None,
-        max_depth: int = None,
-        include_gitignored: bool = None,
-        timeout: int = None,
-        require_confirmation: bool = None,
-        data: dict = None,
-        title: str = None,
-        width: int = None,
-        height: int = None,
-        query: str = None,
-        paths: str = None,
-        src_path: str = None,
-        dest_path: str = None,
-        code: str = None,
-        pattern: str = None,
-    ) -> str:
+        
+    def run(self, **kwargs) -> Any:
         """Execute the wrapped function."""
-        # Build kwargs from non-None parameters
-        import inspect
-
-        sig = inspect.signature(self._func)
-        filtered_kwargs = {}
-
-        # Map parameter names to their actual values
-        param_map = {
-            "path": path,
-            "content": content,
-            "overwrite": overwrite,
-            "sources": sources,
-            "target": target,
-            "recursive": recursive,
-            "from_line": from_line,
-            "to_line": to_line,
-            "search_text": search_text,
-            "replacement_text": replacement_text,
-            "use_regex": use_regex,
-            "case_sensitive": case_sensitive,
-            "max_depth": max_depth,
-            "include_gitignored": include_gitignored,
-            "timeout": timeout,
-            "require_confirmation": require_confirmation,
-            "data": data,
-            "title": title,
-            "width": width,
-            "height": height,
-            "query": query,
-            "paths": paths,
-            "src_path": src_path,
-            "dest_path": dest_path,
-            "code": code,
-            "pattern": pattern,
-        }
-
-        # Only include parameters that exist in the function signature
-        for name, param in sig.parameters.items():
-            if name in param_map and param_map[name] is not None:
-                filtered_kwargs[name] = param_map[name]
-
-        result = self._func(**filtered_kwargs)
-        return str(result) if result is not None else ""
-
+        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
-                ),
+                "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)),
+            "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
     """
-    # Resolve tool_name in outer scope
-    resolved_tool_name = tool_name or getattr(func, "tool_name", func.__name__)
-
+    
     class DynamicFunctionTool(FunctionToolAdapter):
-        permissions = ToolPermissions(read=True, write=True, execute=True)
-        tool_name = resolved_tool_name
-
         def __init__(self):
-            super().__init__(func, DynamicFunctionTool.tool_name, description)
-
-    return DynamicFunctionTool
+            super().__init__(func, tool_name, description)
+    
+    return DynamicFunctionTool

janito/tools/tool_base.py

@@ -1,142 +1,114 @@
-from janito.report_events import ReportEvent, ReportSubtype, ReportAction
-from janito.event_bus.bus import event_bus as default_event_bus
-
-
-from collections import namedtuple
-
-
-class ToolPermissions(namedtuple("ToolPermissions", ["read", "write", "execute"])):
-    __slots__ = ()
-
-    def __new__(cls, read=False, write=False, execute=False):
-        return super().__new__(cls, read, write, execute)
-
-    def __repr__(self):
-        return f"ToolPermissions(read={self.read}, write={self.write}, execute={self.execute})"
-
-
-class ToolBase:
-    """
-    Base class for all tools in the janito project.
-    Extend this class to implement specific tool functionality.
-    
-    Parameters:
-        path (str): Target file path for file operations
-        content (str): File content to write or process
-        overwrite (bool): Whether to overwrite existing files (default: False)
-        sources (str): Source file(s) to copy from
-        target (str): Destination path for copy operations
-        recursive (bool): Whether to process directories recursively
-        from_line (int): Starting line number for file reading
-        to_line (int): Ending line number for file reading
-        search_text (str): Text to search for in files
-        replacement_text (str): Text to replace search matches with
-        use_regex (bool): Whether to treat search as regex pattern
-        case_sensitive (bool): Whether search should be case sensitive
-        max_depth (int): Maximum directory depth to search
-        include_gitignored (bool): Whether to include .gitignored files
-        timeout (int): Timeout in seconds for operations
-        require_confirmation (bool): Whether to require user confirmation
-        data (dict): Chart data for visualization tools
-        title (str): Chart title
-        width (int): Chart width in pixels
-        height (int): Chart height in pixels
-        query (str): Search query for text search
-        paths (str): Directory or file paths to search in
-        src_path (str): Source path for move operations
-        dest_path (str): Destination path for move operations
-        code (str): Python code to execute
-        pattern (str): File pattern to match (e.g., '*.py')
-    """
-
-    permissions: "ToolPermissions" = None  # Required: must be set by subclasses
-
-    def __init__(self, name=None, event_bus=None):
-        if self.permissions is None or not isinstance(
-            self.permissions, ToolPermissions
-        ):
-            raise ValueError(
-                f"Tool '{self.__class__.__name__}' must define a 'permissions' attribute of type ToolPermissions."
-            )
-        self.name = name or self.__class__.__name__
-        self._event_bus = event_bus or default_event_bus
-
-    @property
-    def event_bus(self):
-        return self._event_bus
-
-    @event_bus.setter
-    def event_bus(self, bus):
-        self._event_bus = bus or default_event_bus
-
-    def report_action(self, message: str, action: ReportAction, context: dict = None):
-        """
-        Report that a tool action is starting. This should be the first reporting call for every tool action.
-        """
-        self._event_bus.publish(
-            ReportEvent(
-                subtype=ReportSubtype.ACTION_INFO,
-                message="  " + message,
-                action=action,
-                tool=self.name,
-                context=context,
-            )
-        )
-
-    def report_error(self, message: str, context: dict = None):
-        self._event_bus.publish(
-            ReportEvent(
-                subtype=ReportSubtype.ERROR,
-                message=message,
-                action=None,
-                tool=self.name,
-                context=context,
-            )
-        )
-
-    def report_success(self, message: str, context: dict = None):
-        self._event_bus.publish(
-            ReportEvent(
-                subtype=ReportSubtype.SUCCESS,
-                message=message,
-                action=None,
-                tool=self.name,
-                context=context,
-            )
-        )
-
-    def report_warning(self, message: str, context: dict = None):
-        self._event_bus.publish(
-            ReportEvent(
-                subtype=ReportSubtype.WARNING,
-                message=message,
-                action=None,
-                tool=self.name,
-                context=context,
-            )
-        )
-
-    def report_stdout(self, message: str, context: dict = None):
-        self._event_bus.publish(
-            ReportEvent(
-                subtype=ReportSubtype.STDOUT,
-                message=message,
-                action=None,
-                tool=self.name,
-                context=context,
-            )
-        )
-
-    def report_stderr(self, message: str, context: dict = None):
-        self._event_bus.publish(
-            ReportEvent(
-                subtype=ReportSubtype.STDERR,
-                message=message,
-                action=None,
-                tool=self.name,
-                context=context,
-            )
-        )
-
-    def run(self, *args, **kwargs):
-        raise NotImplementedError("Subclasses must implement the run method.")
+from janito.report_events import ReportEvent, ReportSubtype, ReportAction
+from janito.event_bus.bus import event_bus as default_event_bus
+
+
+from collections import namedtuple
+
+
+class ToolPermissions(namedtuple("ToolPermissions", ["read", "write", "execute"])):
+    __slots__ = ()
+
+    def __new__(cls, read=False, write=False, execute=False):
+        return super().__new__(cls, read, write, execute)
+
+    def __repr__(self):
+        return f"ToolPermissions(read={self.read}, write={self.write}, execute={self.execute})"
+
+
+class ToolBase:
+    """
+    Base class for all tools in the janito project.
+    Extend this class to implement specific tool functionality.
+    """
+
+    permissions: "ToolPermissions" = None  # Required: must be set by subclasses
+
+    def __init__(self, name=None, event_bus=None):
+        if self.permissions is None or not isinstance(
+            self.permissions, ToolPermissions
+        ):
+            raise ValueError(
+                f"Tool '{self.__class__.__name__}' must define a 'permissions' attribute of type ToolPermissions."
+            )
+        self.name = name or self.__class__.__name__
+        self._event_bus = event_bus or default_event_bus
+
+    @property
+    def event_bus(self):
+        return self._event_bus
+
+    @event_bus.setter
+    def event_bus(self, bus):
+        self._event_bus = bus or default_event_bus
+
+    def report_action(self, message: str, action: ReportAction, context: dict = None):
+        """
+        Report that a tool action is starting. This should be the first reporting call for every tool action.
+        """
+        self._event_bus.publish(
+            ReportEvent(
+                subtype=ReportSubtype.ACTION_INFO,
+                message="  " + message,
+                action=action,
+                tool=self.name,
+                context=context,
+            )
+        )
+
+    def report_error(self, message: str, context: dict = None):
+        self._event_bus.publish(
+            ReportEvent(
+                subtype=ReportSubtype.ERROR,
+                message=message,
+                action=None,
+                tool=self.name,
+                context=context,
+            )
+        )
+
+    def report_success(self, message: str, context: dict = None):
+        self._event_bus.publish(
+            ReportEvent(
+                subtype=ReportSubtype.SUCCESS,
+                message=message,
+                action=None,
+                tool=self.name,
+                context=context,
+            )
+        )
+
+    def report_warning(self, message: str, context: dict = None):
+        self._event_bus.publish(
+            ReportEvent(
+                subtype=ReportSubtype.WARNING,
+                message=message,
+                action=None,
+                tool=self.name,
+                context=context,
+            )
+        )
+
+    def report_stdout(self, message: str, context: dict = None):
+        self._event_bus.publish(
+            ReportEvent(
+                subtype=ReportSubtype.STDOUT,
+                message=message,
+                action=None,
+                tool=self.name,
+                context=context,
+            )
+        )
+
+    def report_stderr(self, message: str, context: dict = None):
+        self._event_bus.publish(
+            ReportEvent(
+                subtype=ReportSubtype.STDERR,
+                message=message,
+                action=None,
+                tool=self.name,
+                context=context,
+            )
+        )
+
+    def run(self, *args, **kwargs):
+        raise NotImplementedError("Subclasses must implement the run method.")

janito/tools/tools_schema.py

@@ -7,8 +7,6 @@ class ToolSchemaBase:
     def parse_param_section(self, lines, param_section_headers):
         param_descs = {}
         in_params = False
-        current_param = None
-        
         for line in lines:
             stripped_line = line.strip()
             if any(
@@ -18,21 +16,17 @@ class ToolSchemaBase:
                 in_params = True
                 continue
             if in_params:
-                # Check for parameter definition: "param_name (type): description"
                 m = re.match(
-                    r"([a-zA-Z_][a-zA-Z0-9_]*)\s*(?:\([^)]+\))?\s*:\s*(.+)",
+                    r"([a-zA-Z_][a-zA-Z0-9_]*)\s*(?:\(([^)]+)\))?\s*[:\-]?\s*(.+)",
                     stripped_line,
                 )
                 if m:
-                    param, desc = m.groups()
+                    param, _, desc = m.groups()
                     param_descs[param] = desc.strip()
-                    current_param = param
-                elif current_param and stripped_line and not (
-                    stripped_line.lower().startswith("returns:") or 
-                    stripped_line.lower() == "returns"
-                ):
-                    # Continuation of current parameter description
-                    param_descs[current_param] += " " + stripped_line.strip()
+                elif stripped_line and stripped_line[0] != "-":
+                    if param_descs:
+                        last = list(param_descs)[-1]
+                        param_descs[last] += " " + stripped_line
             if (
                 stripped_line.lower().startswith("returns:")
                 or stripped_line.lower() == "returns"

{janito-3.3.0.dist-info → janito-3.4.0.dist-info}/METADATA

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