janito 3.5.1__py3-none-any.whl → 3.7.0__py3-none-any.whl

janito/{plugins/tools → tools/adapters/local}/python_command_run.py

@@ -5,12 +5,12 @@ import tempfile
 import threading
 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
 
 
-@register_core_tool
-class PythonCommandRun(ToolBase):
+@register_local_tool
+class PythonCommandRunTool(ToolBase):
     """
     Tool to execute Python code using the `python -c` command-line flag.
 
@@ -92,9 +92,6 @@ class PythonCommandRun(ToolBase):
         def stream_output(stream, file_obj, report_func, count_func):
             nonlocal stdout_lines, stderr_lines
             for line in stream:
-                # Check for cancellation
-                if hasattr(self, '_cancel_event') and self._cancel_event.is_set():
-                    break
                 file_obj.write(line)
                 file_obj.flush()
                 from janito.tools.tool_base import ReportAction
@@ -105,11 +102,6 @@ class PythonCommandRun(ToolBase):
                 else:
                     stderr_lines += 1
 
-        # Set up cancellation event
-        from janito.llm.cancellation_manager import get_cancellation_manager
-        cancel_manager = get_cancellation_manager()
-        self._cancel_event = cancel_manager.get_current_cancel_event()
-        
         stdout_thread = threading.Thread(
             target=stream_output,
             args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
@@ -120,16 +112,8 @@ class PythonCommandRun(ToolBase):
         )
         stdout_thread.start()
         stderr_thread.start()
-        
-        try:
-            stdout_thread.join()
-            stderr_thread.join()
-        except Exception as e:
-            # Handle cancellation
-            if self._cancel_event and self._cancel_event.is_set():
-                process.kill()
-                self.report_warning(tr("Code execution cancelled by user"), ReportAction.EXECUTE)
-            raise
+        stdout_thread.join()
+        stderr_thread.join()
         return stdout_lines, stderr_lines
 
     def _wait_for_process(self, process, timeout):

janito/{plugins/tools → tools/adapters/local}/python_file_run.py

@@ -5,12 +5,12 @@ import tempfile
 import threading
 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
 
 
-@register_core_tool
-class PythonFileRun(ToolBase):
+@register_local_tool
+class PythonFileRunTool(ToolBase):
     """
     Tool to execute a specified Python script file.
 
@@ -92,9 +92,6 @@ class PythonFileRun(ToolBase):
         def stream_output(stream, file_obj, report_func, count_func):
             nonlocal stdout_lines, stderr_lines
             for line in stream:
-                # Check for cancellation
-                if hasattr(self, '_cancel_event') and self._cancel_event.is_set():
-                    break
                 file_obj.write(line)
                 file_obj.flush()
                 # Always supply a default action for stdout/stderr reporting
@@ -106,11 +103,6 @@ class PythonFileRun(ToolBase):
                 else:
                     stderr_lines += 1
 
-        # Set up cancellation event
-        from janito.llm.cancellation_manager import get_cancellation_manager
-        cancel_manager = get_cancellation_manager()
-        self._cancel_event = cancel_manager.get_current_cancel_event()
-        
         stdout_thread = threading.Thread(
             target=stream_output,
             args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
@@ -121,16 +113,8 @@ class PythonFileRun(ToolBase):
         )
         stdout_thread.start()
         stderr_thread.start()
-        
-        try:
-            stdout_thread.join()
-            stderr_thread.join()
-        except Exception as e:
-            # Handle cancellation
-            if self._cancel_event and self._cancel_event.is_set():
-                process.kill()
-                self.report_warning(tr("File execution cancelled by user"), ReportAction.EXECUTE)
-            raise
+        stdout_thread.join()
+        stderr_thread.join()
         return stdout_lines, stderr_lines
 
     def _wait_for_process(self, process, timeout):

janito/{plugins/tools → tools/adapters/local}/replace_text_in_file.py

@@ -1,14 +1,14 @@
 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
 import shutil
 import re
-from janito.plugins.tools.validate_file_syntax.core import validate_file_syntax
+from janito.tools.adapters.local.validate_file_syntax.core import validate_file_syntax
 
 
-@register_core_tool
-class ReplaceTextInFile(ToolBase):
+@register_local_tool
+class ReplaceTextInFileTool(ToolBase):
     """
     Replace exact occurrences of a given text in a file.
 

janito/{plugins/tools → tools/adapters/local}/run_bash_command.py

@@ -1,6 +1,6 @@
 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
 import subprocess
 import tempfile
@@ -9,8 +9,8 @@ import os
 import threading
 
 
-@register_core_tool
-class RunBashCommand(ToolBase):
+@register_local_tool
+class RunBashCommandTool(ToolBase):
     """
     Execute a non-interactive command using the bash shell and capture live output.
     This tool explicitly invokes the 'bash' shell (not just the system default shell), so it requires bash to be installed and available in the system PATH. On Windows, this will only work if bash is available (e.g., via WSL, Git Bash, or similar).

janito/{plugins/tools → tools/adapters/local}/run_powershell_command.py

@@ -1,6 +1,6 @@
 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
 import subprocess
 import os
@@ -9,8 +9,8 @@ import tempfile
 import threading
 
 
-@register_core_tool
-class RunPowershellCommand(ToolBase):
+@register_local_tool
+class RunPowershellCommandTool(ToolBase):
     """
     Execute a non-interactive command using the PowerShell shell and capture live output.
     This tool explicitly invokes 'powershell.exe' (on Windows) or 'pwsh' (on other platforms if available).

janito/{plugins/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/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.7.0.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: janito
+Version: 3.7.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