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

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,45 @@
-"""
-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.
+    """
+    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"

janito/tools/tools_schema.py

@@ -1,104 +1,104 @@
-import inspect
-import typing
-import re
-
-
-class ToolSchemaBase:
-    def parse_param_section(self, lines, param_section_headers):
-        param_descs = {}
-        in_params = False
-        for line in lines:
-            stripped_line = line.strip()
-            if any(
-                stripped_line.lower().startswith(h + ":") or stripped_line.lower() == h
-                for h in param_section_headers
-            ):
-                in_params = True
-                continue
-            if in_params:
-                m = re.match(
-                    r"([a-zA-Z_][a-zA-Z0-9_]*)\s*(?:\(([^)]+)\))?\s*[:\-]?\s*(.+)",
-                    stripped_line,
-                )
-                if m:
-                    param, _, desc = m.groups()
-                    param_descs[param] = desc.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"
-            ):
-                break
-        return param_descs
-
-    def parse_return_section(self, lines):
-        in_returns = False
-        return_desc = ""
-        for line in lines:
-            stripped_line = line.strip()
-            if (
-                stripped_line.lower().startswith("returns:")
-                or stripped_line.lower() == "returns"
-            ):
-                in_returns = True
-                continue
-            if in_returns:
-                if stripped_line:
-                    return_desc += (" " if return_desc else "") + stripped_line
-        return return_desc
-
-    def parse_docstring(self, docstring: str):
-        if not docstring:
-            return "", {}, ""
-        lines = docstring.strip().split("\n")
-        summary = lines[0].strip()
-        param_section_headers = ("args", "arguments", "params", "parameters")
-        param_descs = self.parse_param_section(lines[1:], param_section_headers)
-        return_desc = self.parse_return_section(lines[1:])
-        return summary, param_descs, return_desc
-
-    def validate_tool_class(self, tool_class):
-        if not hasattr(tool_class, "tool_name") or not isinstance(
-            tool_class.tool_name, str
-        ):
-            raise ValueError(
-                "Tool class must have a class-level 'tool_name' attribute (str) for registry and schema generation."
-            )
-        if not hasattr(tool_class, "run") or not callable(getattr(tool_class, "run")):
-            raise ValueError("Tool class must have a callable 'run' method.")
-        func = tool_class.run
-        tool_name = tool_class.tool_name
-        sig = inspect.signature(func)
-        if sig.return_annotation is inspect._empty or sig.return_annotation is not str:
-            raise ValueError(
-                f"Tool '{tool_name}' must have an explicit return type of 'str'. Found: {sig.return_annotation}"
-            )
-        missing_type_hints = [
-            name
-            for name, param in sig.parameters.items()
-            if name != "self" and param.annotation is inspect._empty
-        ]
-        if missing_type_hints:
-            raise ValueError(
-                f"Tool '{tool_name}' is missing type hints for parameter(s): {', '.join(missing_type_hints)}.\nAll parameters must have explicit type hints for schema generation."
-            )
-        class_doc = (
-            tool_class.__doc__.strip() if tool_class and tool_class.__doc__ else ""
-        )
-        summary, param_descs, return_desc = self.parse_docstring(class_doc)
-        description = summary
-        if return_desc:
-            description += f"\n\nReturns: {return_desc}"
-        undocumented = [
-            name
-            for name, param in sig.parameters.items()
-            if name != "self" and name not in param_descs
-        ]
-        if undocumented:
-            raise ValueError(
-                f"Tool '{tool_name}' is missing docstring documentation for parameter(s): {', '.join(undocumented)}.\nParameter documentation must be provided in the Tool class docstring, not the method docstring."
-            )
-        return func, tool_name, sig, summary, param_descs, return_desc, description
+import inspect
+import typing
+import re
+
+
+class ToolSchemaBase:
+    def parse_param_section(self, lines, param_section_headers):
+        param_descs = {}
+        in_params = False
+        for line in lines:
+            stripped_line = line.strip()
+            if any(
+                stripped_line.lower().startswith(h + ":") or stripped_line.lower() == h
+                for h in param_section_headers
+            ):
+                in_params = True
+                continue
+            if in_params:
+                m = re.match(
+                    r"([a-zA-Z_][a-zA-Z0-9_]*)\s*(?:\(([^)]+)\))?\s*[:\-]?\s*(.+)",
+                    stripped_line,
+                )
+                if m:
+                    param, _, desc = m.groups()
+                    param_descs[param] = desc.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"
+            ):
+                break
+        return param_descs
+
+    def parse_return_section(self, lines):
+        in_returns = False
+        return_desc = ""
+        for line in lines:
+            stripped_line = line.strip()
+            if (
+                stripped_line.lower().startswith("returns:")
+                or stripped_line.lower() == "returns"
+            ):
+                in_returns = True
+                continue
+            if in_returns:
+                if stripped_line:
+                    return_desc += (" " if return_desc else "") + stripped_line
+        return return_desc
+
+    def parse_docstring(self, docstring: str):
+        if not docstring:
+            return "", {}, ""
+        lines = docstring.strip().split("\n")
+        summary = lines[0].strip()
+        param_section_headers = ("args", "arguments", "params", "parameters")
+        param_descs = self.parse_param_section(lines[1:], param_section_headers)
+        return_desc = self.parse_return_section(lines[1:])
+        return summary, param_descs, return_desc
+
+    def validate_tool_class(self, tool_class):
+        if not hasattr(tool_class, "tool_name") or not isinstance(
+            tool_class.tool_name, str
+        ):
+            raise ValueError(
+                "Tool class must have a class-level 'tool_name' attribute (str) for registry and schema generation."
+            )
+        if not hasattr(tool_class, "run") or not callable(getattr(tool_class, "run")):
+            raise ValueError("Tool class must have a callable 'run' method.")
+        func = tool_class.run
+        tool_name = tool_class.tool_name
+        sig = inspect.signature(func)
+        if sig.return_annotation is inspect._empty or sig.return_annotation is not str:
+            raise ValueError(
+                f"Tool '{tool_name}' must have an explicit return type of 'str'. Found: {sig.return_annotation}"
+            )
+        missing_type_hints = [
+            name
+            for name, param in sig.parameters.items()
+            if name != "self" and param.annotation is inspect._empty
+        ]
+        if missing_type_hints:
+            raise ValueError(
+                f"Tool '{tool_name}' is missing type hints for parameter(s): {', '.join(missing_type_hints)}.\nAll parameters must have explicit type hints for schema generation."
+            )
+        class_doc = (
+            tool_class.__doc__.strip() if tool_class and tool_class.__doc__ else ""
+        )
+        summary, param_descs, return_desc = self.parse_docstring(class_doc)
+        description = summary
+        if return_desc:
+            description += f"\n\nReturns: {return_desc}"
+        undocumented = [
+            name
+            for name, param in sig.parameters.items()
+            if name != "self" and name not in param_descs
+        ]
+        if undocumented:
+            raise ValueError(
+                f"Tool '{tool_name}' is missing docstring documentation for parameter(s): {', '.join(undocumented)}.\nParameter documentation must be provided in the Tool class docstring, not the method docstring."
+            )
+        return func, tool_name, sig, summary, param_descs, return_desc, description

janito/version.py

@@ -1,4 +1,4 @@
-# janito/version.py
-"""Single source of truth for the janito package version."""
-
-__version__ = "2.3.0"
+# janito/version.py
+"""Single source of truth for the janito package version."""
+
+__version__ = "2.3.1"