janito 3.6.1__py3-none-any.whl → 3.8.0__py3-none-any.whl

janito/{plugins/tools/core → 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 .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/adapters/local/view_file.py

@@ -0,0 +1,172 @@
+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.tools.tool_utils import pluralize
+from janito.i18n import tr
+from janito.tools.loop_protection_decorator import protect_against_loops
+
+
+@register_local_tool
+class ViewFileTool(ToolBase):
+    """
+    Read lines from a file. You can specify a line range, or read the entire file by simply omitting the from_line and to_line parameters.
+
+    Args:
+        path (str): Path to the file to read lines from.
+        from_line (int, optional): Starting line number (1-based). Omit to start from the first line.
+        to_line (int, optional): Ending line number (1-based). Omit to read to the end of the file.
+
+    To read the full file, just provide path and leave from_line and to_line unset.
+
+    Returns:
+        str: File content with a header indicating the file name and line range. Example:
+            - "---\nFile: /path/to/file.py | Lines: 1-10 (of 100)\n---\n<lines...>"
+            - "---\nFile: /path/to/file.py | All lines (total: 100 (all))\n---\n<all lines...>"
+            - "Error reading file: <error message>"
+            - "❗ not found"
+    """
+
+    permissions = ToolPermissions(read=True)
+    tool_name = "view_file"
+
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
+    def run(self, path: str, from_line: int = None, to_line: int = None) -> str:
+        import os
+        from janito.tools.tool_utils import display_path
+        from janito.tools.path_utils import expand_path
+
+        path = expand_path(path)
+        disp_path = display_path(path)
+        self.report_action(
+            tr("📖 View '{disp_path}'", disp_path=disp_path),
+            ReportAction.READ,
+        )
+        try:
+            if os.path.isdir(path):
+                return self._list_directory(path, disp_path)
+            lines = self._read_file_lines(path)
+            selected, selected_len, total_lines = self._select_lines(
+                lines, from_line, to_line
+            )
+            self._report_success(selected_len, from_line, to_line, total_lines)
+            header = self._format_header(
+                disp_path, from_line, to_line, selected_len, total_lines
+            )
+            return header + "".join(selected)
+        except FileNotFoundError as e:
+            self.report_warning(tr("❗ not found"))
+            return f"Error reading file: {e}"
+        except Exception as e:
+            self.report_error(tr(" ❌ Error: {error}", error=e))
+            return tr("Error reading file: {error}", error=e)
+
+    def _list_directory(self, path, disp_path):
+        import os
+
+        try:
+            entries = os.listdir(path)
+            entries.sort()
+            # Suffix subdirectories with '/'
+            formatted_entries = []
+            for entry in entries:
+                full_path = os.path.join(path, entry)
+                if os.path.isdir(full_path):
+                    formatted_entries.append(entry + "/")
+                else:
+                    formatted_entries.append(entry)
+            header = (
+                f"--- view_file: {disp_path} [directory, {len(entries)} entries] ---\n"
+            )
+            listing = "\n".join(formatted_entries)
+            self.report_success(tr("📁 Directory ({count} items)", count=len(entries)))
+            return header + listing + "\n"
+        except Exception as e:
+            self.report_error(tr(" ❌ Error listing directory: {error}", error=e))
+            return tr("Error listing directory: {error}", error=e)
+
+    def _read_file_lines(self, path):
+        """Read all lines from the file."""
+        with open(path, "r", encoding="utf-8", errors="replace") as f:
+            return f.readlines()
+
+    def _select_lines(self, lines, from_line, to_line):
+        """Select the requested lines and return them with their count and total lines."""
+        selected = lines[
+            (from_line - 1 if from_line else 0) : (to_line if to_line else None)
+        ]
+        selected_len = len(selected)
+        total_lines = len(lines)
+        return selected, selected_len, total_lines
+
+    def _report_success(self, selected_len, from_line, to_line, total_lines):
+        """Report the success message after reading lines."""
+        if from_line and to_line:
+            requested = to_line - from_line + 1
+            at_end = to_line >= total_lines or selected_len < requested
+            if at_end:
+                self.report_success(
+                    tr(
+                        " ✅ {selected_len} {line_word} (end)",
+                        selected_len=selected_len,
+                        line_word=pluralize("line", selected_len),
+                    )
+                )
+            elif to_line < total_lines:
+                self.report_success(
+                    tr(
+                        " ✅ {selected_len} {line_word} ({remaining} to end)",
+                        selected_len=selected_len,
+                        line_word=pluralize("line", selected_len),
+                        remaining=total_lines - to_line,
+                    )
+                )
+        else:
+            self.report_success(
+                tr(
+                    " ✅ {selected_len} {line_word} (all)",
+                    selected_len=selected_len,
+                    line_word=pluralize("line", selected_len),
+                )
+            )
+
+    def _format_header(self, disp_path, from_line, to_line, selected_len, total_lines):
+        """Format the header for the output."""
+        if from_line and to_line:
+            requested = to_line - from_line + 1
+            at_end = selected_len < requested or to_line >= total_lines
+            if at_end:
+                return tr(
+                    "---\n{disp_path} {from_line}-{to_line} (end)\n---\n",
+                    disp_path=disp_path,
+                    from_line=from_line,
+                    to_line=to_line,
+                )
+            else:
+                return tr(
+                    "---\n{disp_path} {from_line}-{to_line} (of {total_lines})\n---\n",
+                    disp_path=disp_path,
+                    from_line=from_line,
+                    to_line=to_line,
+                    total_lines=total_lines,
+                )
+        elif from_line:
+            return tr(
+                "---\n{disp_path} {from_line}-END (of {total_lines})\n---\n",
+                disp_path=disp_path,
+                from_line=from_line,
+                total_lines=total_lines,
+            )
+        else:
+            return tr(
+                "---\n{disp_path} All lines (total: {total_lines} (all))\n---\n",
+                disp_path=disp_path,
+                total_lines=total_lines,
+            )
+
+    def _handle_read_error(self, e):
+        """Handle file read errors and report appropriately."""
+        if isinstance(e, FileNotFoundError):
+            self.report_error(tr("❗ not found"), ReportAction.READ)
+            return tr("❗ not found")
+        self.report_error(tr(" ❌ Error: {error}", error=e), ReportAction.READ)
+        return tr("Error reading file: {error}", error=e)

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/tools/loop_protection_decorator.py

@@ -1,140 +1,143 @@
 import functools
 import time
 import threading
-from typing import Any, Tuple
+from typing import Callable, Any
+from janito.tools.loop_protection import LoopProtection
+from janito.tools.tool_use_tracker import normalize_path
+
 
 # Global tracking for decorator-based loop protection
 _decorator_call_tracker = {}
 _decorator_call_tracker_lock = threading.Lock()
 
 
-def _normalize_key_value(key_field: str, key_value: Any) -> Any:
-    """Normalize key values, especially paths, so different representations map to the same key."""
-    if key_value is None:
-        return None
-
-    try:
-        if isinstance(key_field, str) and "path" in key_field.lower():
-            from janito.tools.tool_use_tracker import (
-                normalize_path as _norm,  # reuse existing normalization
-            )
-
-            if isinstance(key_value, str):
-                return _norm(key_value)
-            if isinstance(key_value, (list, tuple)):
-                return tuple(_norm(v) if isinstance(v, str) else v for v in key_value)
-    except Exception:
-        # Best-effort normalization – fall back to original value
-        pass
-
-    return key_value
-
-
-def _get_param_value(func, args, kwargs, key_field: str):
-    """Extract the watched parameter value from args/kwargs using function signature."""
-    if key_field in kwargs:
-        return kwargs[key_field]
-
-    # Handle positional arguments by mapping to parameter names
-    if len(args) > 1:  # args[0] is self
-        import inspect
-
-        try:
-            sig = inspect.signature(func)
-            param_names = list(sig.parameters.keys())
-            if key_field in param_names:
-                idx = param_names.index(key_field)
-                if idx < len(args):
-                    return args[idx]
-        except Exception:
-            return None
-
-    return None
-
-
-def _determine_operation_name(func, args, kwargs, key_field: str) -> str:
-    """Build the operation name for rate limiting, optionally including a normalized key value."""
-    if key_field:
-        raw_value = _get_param_value(func, args, kwargs, key_field)
-        if raw_value is not None:
-            norm_value = _normalize_key_value(key_field, raw_value)
-            return f"{func.__name__}_{norm_value}"
-    return func.__name__
-
-
-def _check_and_record(
-    op_name: str,
-    current_time: float,
-    time_window: float,
-    max_calls: int,
-    tool_instance: Any,
-) -> Tuple[bool, str]:
-    """Check loop limits for op_name and record the call. Returns (exceeded, message)."""
-    with _decorator_call_tracker_lock:
-        # Clean old timestamps
-        if op_name in _decorator_call_tracker:
-            _decorator_call_tracker[op_name] = [
-                ts
-                for ts in _decorator_call_tracker[op_name]
-                if current_time - ts <= time_window
-            ]
-
-        # Check limit
-        if (
-            op_name in _decorator_call_tracker
-            and len(_decorator_call_tracker[op_name]) >= max_calls
-        ):
-            if all(
-                current_time - ts <= time_window
-                for ts in _decorator_call_tracker[op_name]
-            ):
-                msg = (
-                    f"Loop protection: Too many {op_name} operations in a short time period "
-                    f"({max_calls} calls in {time_window}s). Please try a different approach or wait before retrying."
-                )
-                if hasattr(tool_instance, "report_error"):
-                    try:
-                        tool_instance.report_error(msg)
-                    except Exception:
-                        pass
-                return True, msg
-
-        # Record this call
-        if op_name not in _decorator_call_tracker:
-            _decorator_call_tracker[op_name] = []
-        _decorator_call_tracker[op_name].append(current_time)
-
-    return False, ""
-
-
 def protect_against_loops(
     max_calls: int = 5, time_window: float = 10.0, key_field: str = None
 ):
     """
     Decorator that adds loop protection to tool run methods.
 
-    Tracks calls within a sliding time window and prevents excessive repeated operations.
-    When key_field is provided, the limit is applied per unique normalized value of that parameter
-    (e.g., per-path protection for file tools).
+    This decorator monitors tool executions and prevents excessive calls within
+    a configurable time window. It helps prevent infinite loops or excessive
+    resource consumption when tools are called repeatedly.
+
+    When the configured limits are exceeded, the decorator raises a RuntimeError
+    with a descriptive message. This exception will propagate up the call stack
+    unless caught by a try/except block in the calling code.
+
+    The decorator works by:
+    1. Tracking the number of calls to the decorated function
+    2. Checking if the calls exceed the configured limits
+    3. Raising a RuntimeError if a potential loop is detected
+    4. Allowing the method to proceed normally if the operation is safe
+
+    Args:
+        max_calls (int): Maximum number of calls allowed within the time window.
+                        Defaults to 5 calls.
+        time_window (float): Time window in seconds for detecting excessive calls.
+                            Defaults to 10.0 seconds.
+        key_field (str, optional): The parameter name to use for key matching instead of function name.
+                                 If provided, the decorator will track calls based on the value of this
+                                 parameter rather than the function name. Useful for tools that operate
+                                 on specific files or resources.
+
+    Example:
+        >>> @protect_against_loops(max_calls=3, time_window=5.0)
+        >>> def run(self, path: str) -> str:
+        >>>     # Implementation here
+        >>>     pass
+
+        >>> @protect_against_loops(max_calls=10, time_window=30.0)
+        >>> def run(self, file_paths: list) -> str:
+        >>>     # Implementation here
+        >>>     pass
+
+        >>> @protect_against_loops(max_calls=5, time_window=10.0, key_field='path')
+        >>> def run(self, path: str) -> str:
+        >>>     # This will track calls per unique path value
+        >>>     pass
+
+    Note:
+        When loop protection is triggered, a RuntimeError will be raised with a
+        descriptive message. This exception will propagate up the call stack
+        unless caught by a try/except block in the calling code.
     """
 
     def decorator(func):
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
-            # Methods should always have self; if not, execute directly.
+            # Get the tool instance (self)
             if not args:
+                # This shouldn't happen in normal usage as methods need self
                 return func(*args, **kwargs)
 
-            op_name = _determine_operation_name(func, args, kwargs, key_field)
-            exceeded, msg = _check_and_record(
-                op_name=op_name,
-                current_time=time.time(),
-                time_window=time_window,
-                max_calls=max_calls,
-                tool_instance=args[0],
-            )
-            if exceeded:
-                return msg
+            # Determine the operation key
+            if key_field:
+                # Use the key_field parameter value as the operation key
+                key_value = None
+                if key_field in kwargs:
+                    key_value = kwargs[key_field]
+                elif len(args) > 1:
+                    # Handle positional arguments - need to map parameter names
+                    import inspect
+
+                    try:
+                        sig = inspect.signature(func)
+                        param_names = list(sig.parameters.keys())
+                        if key_field in param_names:
+                            field_index = param_names.index(key_field)
+                            if field_index < len(args):
+                                key_value = args[field_index]
+                    except (ValueError, TypeError):
+                        pass
+
+                if key_value is not None:
+                    op_name = f"{func.__name__}_{key_value}"
+                else:
+                    op_name = func.__name__
+            else:
+                # Use the function name as the operation name
+                op_name = func.__name__
+
+            # Check call limits
+            current_time = time.time()
+
+            with _decorator_call_tracker_lock:
+                # Clean up old entries outside the time window
+                if op_name in _decorator_call_tracker:
+                    _decorator_call_tracker[op_name] = [
+                        timestamp
+                        for timestamp in _decorator_call_tracker[op_name]
+                        if current_time - timestamp <= time_window
+                    ]
+
+                # Check if we're exceeding the limit
+                if op_name in _decorator_call_tracker:
+                    if len(_decorator_call_tracker[op_name]) >= max_calls:
+                        # Check if all recent calls are within the time window
+                        if all(
+                            current_time - timestamp <= time_window
+                            for timestamp in _decorator_call_tracker[op_name]
+                        ):
+                            # Return loop protection message as string instead of raising exception
+                            error_msg = f"Loop protection: Too many {op_name} operations in a short time period ({max_calls} calls in {time_window}s). Please try a different approach or wait before retrying."
+
+                            # Try to report the error through the tool's reporting mechanism
+                            tool_instance = args[0] if args else None
+                            if hasattr(tool_instance, "report_error"):
+                                try:
+                                    tool_instance.report_error(error_msg)
+                                except Exception:
+                                    pass  # If reporting fails, we still return the message
+
+                            return error_msg
+
+                # Record this call
+                if op_name not in _decorator_call_tracker:
+                    _decorator_call_tracker[op_name] = []
+                _decorator_call_tracker[op_name].append(current_time)
+
+            # Proceed with the original function
             return func(*args, **kwargs)
 
         return wrapper

janito-3.8.0.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: janito
+Version: 3.8.0
+Summary: A new Python package called janito.
+Author-email: João Pinto <janito@ikignosis.org>
+Project-URL: Homepage, https://github.com/ikignosis/janito
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: attrs==25.3.0
+Requires-Dist: rich==14.0.0
+Requires-Dist: pathspec==0.12.1
+Requires-Dist: setuptools>=61.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: jinja2>=3.0.0
+Requires-Dist: prompt_toolkit>=3.0.51
+Requires-Dist: lxml>=5.4.0
+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"
+Requires-Dist: ruff==0.11.9; extra == "dev"
+Requires-Dist: detect-secrets==1.4.0; extra == "dev"
+Requires-Dist: codespell==2.4.1; extra == "dev"
+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
+
+```bash
+$ nctl --help
+Usage: nctl <command>
+
+Interact with Nine API resources. See https://docs.nineapis.ch for the full API docs.
+
+Run "nctl <command> --help" for more information on a command.
+```
+
+## Setup
+
+```bash
+# If you have go already installed
+go install github.com/ninech/nctl@latest
+
+# Homebrew
+brew install ninech/taps/nctl
+
+# Debian/Ubuntu
+echo "deb [trusted=yes] https://repo.nine.ch/deb/ /" | sudo tee /etc/apt/sources.list.d/repo.nine.ch.list
+sudo apt-get update
+sudo apt-get install nctl
+
+# Fedora/RHEL
+cat <<EOF > /etc/yum.repos.d/repo.nine.ch.repo
+[repo.nine.ch]
+name=Nine Repo
+baseurl=https://repo.nine.ch/yum/
+enabled=1
+gpgcheck=0
+EOF
+dnf install nctl
+
+# Arch
+# Install yay: https://github.com/Jguer/yay#binary
+yay --version
+yay -S nctl-bin
+```
+
+For Windows users, nctl is also built for arm64 and amd64. You can download the
+latest exe file from the [releases](https://github.com/ninech/nctl/releases) and
+install it.
+
+## Getting started
+
+* login to the API using `nctl auth login`
+* run `nctl --help` to get a list of all available commands