janito 2.3.0__py3-none-any.whl → 2.4.0__py3-none-any.whl

janito/tools/tool_base.py

@@ -1,105 +1,118 @@
-from janito.report_events import ReportEvent, ReportSubtype, ReportAction
-from janito.event_bus.bus import event_bus as default_event_bus
-
-
-class ToolBase:
-    """
-    Base class for all tools in the janito project.
-    Extend this class to implement specific tool functionality.
-    """
-    provides_execution = False  # Indicates if the tool provides execution capability (default: False)
-
-    def __init__(self, name=None, event_bus=None):
-        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_info(self, message: str, context: dict = None):
-        self._event_bus.publish(
-            ReportEvent(
-                subtype=ReportSubtype.ACTION_INFO,
-                message=message,
-                action=None,
-                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_info(self, message: str, context: dict = None):
+        self._event_bus.publish(
+            ReportEvent(
+                subtype=ReportSubtype.ACTION_INFO,
+                message=message,
+                action=None,
+                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/tool_events.py

@@ -1,58 +1,58 @@
-import attr
-from typing import Any, ClassVar
-from janito.event_bus.event import Event
-
-
-@attr.s(auto_attribs=True, kw_only=True)
-class ToolEvent(Event):
-    """
-    Base class for events related to tool calls (external or internal tools).
-    Includes tool name and request ID for correlation.
-    """
-
-    category: ClassVar[str] = "tool"
-    tool_name: str
-    request_id: str
-
-
-@attr.s(auto_attribs=True, kw_only=True)
-class ToolCallStarted(ToolEvent):
-    """
-    Event indicating that a tool call has started.
-    Contains the arguments passed to the tool.
-    """
-
-    arguments: Any
-
-
-@attr.s(auto_attribs=True, kw_only=True)
-class ToolCallFinished(ToolEvent):
-    """
-    Event indicating that a tool call has finished.
-    Contains the result returned by the tool.
-    """
-
-    result: Any
-
-
-@attr.s(auto_attribs=True, kw_only=True)
-class ToolRunError(ToolEvent):
-    """
-    Event indicating that an error occurred during tool execution (for event bus, not exception handling).
-    """
-
-    error: str
-    exception: Exception = None
-    arguments: Any = None
-
-
-@attr.s(auto_attribs=True, kw_only=True)
-class ToolCallError(ToolEvent):
-    """
-    Event indicating that the tool could not be called (e.g., tool not found, invalid arguments, or invocation failure).
-    This is distinct from ToolRunError, which is for errors during execution after the tool has started running.
-    """
-
-    error: str
-    exception: Exception = None
-    arguments: Any = None
+import attr
+from typing import Any, ClassVar
+from janito.event_bus.event import Event
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class ToolEvent(Event):
+    """
+    Base class for events related to tool calls (external or internal tools).
+    Includes tool name and request ID for correlation.
+    """
+
+    category: ClassVar[str] = "tool"
+    tool_name: str
+    request_id: str
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class ToolCallStarted(ToolEvent):
+    """
+    Event indicating that a tool call has started.
+    Contains the arguments passed to the tool.
+    """
+
+    arguments: Any
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class ToolCallFinished(ToolEvent):
+    """
+    Event indicating that a tool call has finished.
+    Contains the result returned by the tool.
+    """
+
+    result: Any
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class ToolRunError(ToolEvent):
+    """
+    Event indicating that an error occurred during tool execution (for event bus, not exception handling).
+    """
+
+    error: str
+    exception: Exception = None
+    arguments: Any = None
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class ToolCallError(ToolEvent):
+    """
+    Event indicating that the tool could not be called (e.g., tool not found, invalid arguments, or invocation failure).
+    This is distinct from ToolRunError, which is for errors during execution after the tool has started running.
+    """
+
+    error: str
+    exception: Exception = None
+    arguments: Any = None

janito/tools/tool_run_exception.py

@@ -1,12 +1,12 @@
-class ToolRunException(Exception):
-    """
-    Exception raised when a tool runs but fails due to an internal error or runtime exception.
-    This is distinct from ToolRunError event, which is for event bus notification.
-    """
-
-    def __init__(self, tool_name, error, arguments=None, exception=None):
-        self.tool_name = tool_name
-        self.error = error
-        self.arguments = arguments
-        self.original_exception = exception
-        super().__init__(f"ToolRunException: {tool_name}: {error}")
+class ToolRunException(Exception):
+    """
+    Exception raised when a tool runs but fails due to an internal error or runtime exception.
+    This is distinct from ToolRunError event, which is for event bus notification.
+    """
+
+    def __init__(self, tool_name, error, arguments=None, exception=None):
+        self.tool_name = tool_name
+        self.error = error
+        self.arguments = arguments
+        self.original_exception = exception
+        super().__init__(f"ToolRunException: {tool_name}: {error}")

janito/tools/tool_use_tracker.py

@@ -1,81 +1,81 @@
-import threading
-import os
-from typing import Any, Dict, List
-
-
-def normalize_path(path: str) -> str:
-    if not isinstance(path, str):
-        return path
-    return os.path.normcase(os.path.abspath(path))
-
-
-class ToolUseTracker:
-    _instance = None
-    _lock = threading.Lock()
-
-    def __new__(cls):
-        if not cls._instance:
-            with cls._lock:
-                if not cls._instance:
-                    cls._instance = super().__new__(cls)
-                    cls._instance._history = []
-        return cls._instance
-
-    def record(self, tool_name: str, params: Dict[str, Any], result: Any = None):
-        # Normalize file_path in params if present
-        norm_params = params.copy()
-        if "file_path" in norm_params:
-            norm_params["file_path"] = normalize_path(norm_params["file_path"])
-        self._history.append(
-            {"tool": tool_name, "params": norm_params, "result": result}
-        )
-
-    def get_history(self) -> List[Dict[str, Any]]:
-        return list(self._history)
-
-    def get_operations_on_file(self, file_path: str) -> List[Dict[str, Any]]:
-        norm_file_path = normalize_path(file_path)
-        ops = []
-        for entry in self._history:
-            params = entry["params"]
-            # Normalize any string param values for comparison
-            for v in params.values():
-                if isinstance(v, str) and normalize_path(v) == norm_file_path:
-                    ops.append(entry)
-                    break
-        return ops
-
-    def file_fully_read(self, file_path: str) -> bool:
-        norm_file_path = normalize_path(file_path)
-        for entry in self._history:
-            if entry["tool"] == "view_file":
-                params = entry["params"]
-                if (
-                    "file_path" in params
-                    and normalize_path(params["file_path"]) == norm_file_path
-                ):
-                    # If both from_line and to_line are None, full file was read
-                    if (
-                        params.get("from_line") is None
-                        and params.get("to_line") is None
-                    ):
-                        return True
-        return False
-
-    def last_operation_is_full_read_or_replace(self, file_path: str) -> bool:
-        ops = self.get_operations_on_file(file_path)
-        if not ops:
-            return False
-        last = ops[-1]
-        if last["tool"] == "view_file":
-            params = last["params"]
-            if params.get("from_line") is None and params.get("to_line") is None:
-                return True
-        return False
-
-    def clear_history(self):
-        self._history.clear()
-
-    @classmethod
-    def instance(cls):
-        return cls()
+import threading
+import os
+from typing import Any, Dict, List
+
+
+def normalize_path(path: str) -> str:
+    if not isinstance(path, str):
+        return path
+    return os.path.normcase(os.path.abspath(path))
+
+
+class ToolUseTracker:
+    _instance = None
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        if not cls._instance:
+            with cls._lock:
+                if not cls._instance:
+                    cls._instance = super().__new__(cls)
+                    cls._instance._history = []
+        return cls._instance
+
+    def record(self, tool_name: str, params: Dict[str, Any], result: Any = None):
+        # Normalize file_path in params if present
+        norm_params = params.copy()
+        if "file_path" in norm_params:
+            norm_params["file_path"] = normalize_path(norm_params["file_path"])
+        self._history.append(
+            {"tool": tool_name, "params": norm_params, "result": result}
+        )
+
+    def get_history(self) -> List[Dict[str, Any]]:
+        return list(self._history)
+
+    def get_operations_on_file(self, file_path: str) -> List[Dict[str, Any]]:
+        norm_file_path = normalize_path(file_path)
+        ops = []
+        for entry in self._history:
+            params = entry["params"]
+            # Normalize any string param values for comparison
+            for v in params.values():
+                if isinstance(v, str) and normalize_path(v) == norm_file_path:
+                    ops.append(entry)
+                    break
+        return ops
+
+    def file_fully_read(self, file_path: str) -> bool:
+        norm_file_path = normalize_path(file_path)
+        for entry in self._history:
+            if entry["tool"] == "view_file":
+                params = entry["params"]
+                if (
+                    "file_path" in params
+                    and normalize_path(params["file_path"]) == norm_file_path
+                ):
+                    # If both from_line and to_line are None, full file was read
+                    if (
+                        params.get("from_line") is None
+                        and params.get("to_line") is None
+                    ):
+                        return True
+        return False
+
+    def last_operation_is_full_read_or_replace(self, file_path: str) -> bool:
+        ops = self.get_operations_on_file(file_path)
+        if not ops:
+            return False
+        last = ops[-1]
+        if last["tool"] == "view_file":
+            params = last["params"]
+            if params.get("from_line") is None and params.get("to_line") is None:
+                return True
+        return False
+
+    def clear_history(self):
+        self._history.clear()
+
+    @classmethod
+    def instance(cls):
+        return cls()

janito/tools/tool_utils.py

@@ -1,45 +1,43 @@
-"""
-Utility functions for the janito project.
-Add your shared helper functions here.
-"""
-
-import os
-import urllib.parse
-
-
-def example_utility_function(x):
-    """A simple example utility function."""
-    return f"Processed: {x}"
-
-
-def display_path(path):
-    """
-    Returns a display-friendly path. Injects an ANSI hyperlink to a local web file viewer using a hardcoded port.
-    Args:
-        path (str): Path to display.
-    Returns:
-        str: Display path, as an ANSI hyperlink.
-    """
-    from janito.cli.config import get_termweb_port
-
-    port = get_termweb_port()
-    if os.path.isabs(path):
-        cwd = os.path.abspath(os.getcwd())
-        abs_path = os.path.abspath(path)
-        # Check if the absolute path is within the current working directory
-        if abs_path.startswith(cwd + os.sep):
-            disp = os.path.relpath(abs_path, cwd)
-        else:
-            disp = path
-    else:
-        disp = os.path.relpath(path)
-    url = f"http://localhost:{port}/?path={urllib.parse.quote(path)}"
-    # Use Rich markup for hyperlinks
-    return f"[link={url}]{disp}[/link]"
-
-
-def pluralize(word: str, count: int) -> str:
-    """Return the pluralized form of word if count != 1, unless word already ends with 's'."""
-    if count == 1 or word.endswith("s"):
-        return word
-    return word + "s"
+"""
+Utility functions for the janito project.
+Add your shared helper functions here.
+"""
+
+import os
+import urllib.parse
+
+
+def example_utility_function(x):
+    """A simple example utility function."""
+    return f"Processed: {x}"
+
+
+def display_path(path):
+    """
+    Returns a display-friendly path. Injects an ANSI hyperlink to a local web file viewer using a hardcoded port.
+    Args:
+        path (str): Path to display.
+    Returns:
+        str: Display path, as an ANSI hyperlink.
+    """
+    
+    port = 8088
+    if os.path.isabs(path):
+        cwd = os.path.abspath(os.getcwd())
+        abs_path = os.path.abspath(path)
+        # Check if the absolute path is within the current working directory
+        if abs_path.startswith(cwd + os.sep):
+            disp = os.path.relpath(abs_path, cwd)
+        else:
+            disp = path
+    else:
+        disp = os.path.relpath(path)
+    # URL injection removed; just return display path
+    return disp
+
+
+def pluralize(word: str, count: int) -> str:
+    """Return the pluralized form of word if count != 1, unless word already ends with 's'."""
+    if count == 1 or word.endswith("s"):
+        return word
+    return word + "s"