janito 1.14.3__py3-none-any.whl → 2.0.0__py3-none-any.whl

janito/agent/rich_message_handler.py

@@ -1,115 +0,0 @@
-from rich.console import Console
-from janito.agent.runtime_config import runtime_config, unified_config
-from janito.agent.message_handler_protocol import MessageHandlerProtocol
-
-console = Console()
-
-
-def _print_metadata_if_verbose(msg):
-    if unified_config.get("verbose_messages", False):
-        # Exclude 'message' field from metadata
-        meta = {k: v for k, v in msg.items() if k != "message"}
-        if meta:
-            console.print("[bold][cyan]Message metadata:[/cyan][/bold]")
-            for k, v in meta.items():
-                console.print(f"  [green]{k}[/green]: [magenta]{v}[/magenta]")
-
-
-class RichMessageHandler(MessageHandlerProtocol):
-    """
-    Unified message handler for all output (tool, agent, system) using Rich for styled output.
-    """
-
-    def __init__(self):
-        self.console = console
-
-    def handle_message(self, msg, msg_type=None):
-        """
-        Handles a dict with 'type' and 'message'.
-        All messages must be dicts. Raises if not.
-        """
-        trust = runtime_config.get("trust")
-        if trust is None:
-            trust = unified_config.get("trust", False)
-
-        if not isinstance(msg, dict):
-            raise TypeError(
-                f"RichMessageHandler.handle_message expects a dict with 'type' and 'message', got {type(msg)}: {msg!r}"
-            )
-
-        msg_type = msg.get("type", "info")
-        message = msg.get("message", "")
-
-        if trust and msg_type != "content":
-            return  # Suppress all except content
-
-        handler_map = {
-            "content": self._handle_content,
-            "info": self._handle_info,
-            "success": self._handle_success,
-            "error": self._handle_error,
-            "progress": self._handle_progress,
-            "warning": self._handle_warning,
-            "stdout": self._handle_stdout,
-            "stderr": self._handle_stderr,
-        }
-
-        handler = handler_map.get(msg_type)
-        if handler:
-            handler(msg, message)
-        # Ignore unsupported message types silently
-
-    def _handle_content(self, msg, message):
-        from rich.markdown import Markdown
-
-        _print_metadata_if_verbose(msg)
-        self.console.print(Markdown(message))
-
-    def _handle_info(self, msg, message):
-        action_type = msg.get("action_type", None)
-        style = "cyan"  # default
-        action_type_name = action_type.name if action_type else None
-        if action_type_name == "READ":
-            style = "cyan"
-        elif action_type_name == "WRITE":
-            style = "bright_magenta"
-        elif action_type_name == "EXECUTE":
-            style = "yellow"
-        _print_metadata_if_verbose(msg)
-        self.console.print(f"  {message}", style=style, end="")
-
-    def _handle_success(self, msg, message):
-        _print_metadata_if_verbose(msg)
-        self.console.print(message, style="bold green", end="\n")
-
-    def _handle_error(self, msg, message):
-        _print_metadata_if_verbose(msg)
-        self.console.print(message, style="bold red", end="\n")
-
-    def _handle_progress(self, msg, message=None):
-        _print_metadata_if_verbose(msg)
-        # Existing logic for progress messages (if any)
-        # Placeholder: implement as needed
-        pass
-
-    def _handle_warning(self, msg, message):
-        _print_metadata_if_verbose(msg)
-        self.console.print(message, style="bold yellow", end="\n")
-
-    def _handle_stdout(self, msg, message):
-        from rich.text import Text
-
-        _print_metadata_if_verbose(msg)
-        self.console.print(
-            Text(message, style="on #003300", no_wrap=True, overflow=None),
-            end="",
-        )
-
-    def _handle_stderr(self, msg, message):
-        from rich.text import Text
-
-        _print_metadata_if_verbose(msg)
-        self.console.print(
-            Text(message, style="on #330000", no_wrap=True, overflow=None),
-            end="",
-        )

janito/agent/runtime_config.py

@@ -1,36 +0,0 @@
-from .config import BaseConfig, effective_config
-
-
-class RuntimeConfig(BaseConfig):
-    """In-memory only config, reset on restart"""
-
-    pass
-
-
-runtime_config = RuntimeConfig()
-
-
-class UnifiedConfig:
-    """
-    Config lookup order:
-    1. runtime_config (in-memory, highest priority)
-    2. effective_config (local/global, read-only)
-    """
-
-    def __init__(self, runtime_cfg, effective_cfg):
-        self.runtime_cfg = runtime_cfg
-        self.effective_cfg = effective_cfg
-
-    def get(self, key, default=None):
-        val = self.runtime_cfg.get(key)
-        if val is not None:
-            return val
-        return self.effective_cfg.get(key, default)
-
-    def all(self):
-        merged = dict(self.effective_cfg.all())
-        merged.update(self.runtime_cfg.all())
-        return merged
-
-
-unified_config = UnifiedConfig(runtime_config, effective_config)

janito/agent/test_handler_protocols.py

@@ -1,47 +0,0 @@
-from janito.agent.message_handler_protocol import MessageHandlerProtocol
-from janito.agent.event_handler_protocol import EventHandlerProtocol
-from janito.agent.event_dispatcher import EventDispatcher
-
-
-class DummyMessageHandler(MessageHandlerProtocol):
-    def __init__(self):
-        self.last_message = None
-
-    def handle_message(self, msg, msg_type=None):
-        self.last_message = (msg, msg_type)
-
-
-class DummyEvent:
-    def __init__(self, type_, payload):
-        self.type = type_
-        self.payload = payload
-
-
-class DummyEventHandler(EventHandlerProtocol):
-    def __init__(self):
-        self.last_event = None
-
-    def handle_event(self, event):
-        self.last_event = event
-
-
-def test_message_handler():
-    handler = DummyMessageHandler()
-    handler.handle_message({"type": "info", "message": "hello"}, "info")
-    assert handler.last_message[0]["message"] == "hello"
-    print("MessageHandlerProtocol test passed")
-
-
-def test_event_dispatcher():
-    dispatcher = EventDispatcher()
-    handler = DummyEventHandler()
-    dispatcher.register("test", handler)
-    event = DummyEvent("test", {"foo": "bar"})
-    dispatcher.dispatch(event)
-    assert handler.last_event.payload["foo"] == "bar"
-    print("EventHandlerProtocol/EventDispatcher test passed")
-
-
-if __name__ == "__main__":
-    test_message_handler()
-    test_event_dispatcher()

janito/agent/test_openai_schema_generator.py

@@ -1,93 +0,0 @@
-"""
-Tests for OpenAISchemaGenerator class-based API.
-"""
-
-import pytest
-from janito.agent.openai_schema_generator import OpenAISchemaGenerator
-
-
-class DummyTool:
-    """
-    Dummy tool for testing.
-
-    Args:
-        foo (str): Foo parameter.
-        bar (int): Bar parameter.
-    Returns:
-        The result as a string.
-    """
-
-    name = "dummy_tool"
-
-    def run(self, foo: str, bar: int) -> str:
-        """Run the dummy tool."""
-        return f"{foo}-{bar}"
-
-
-# Simulate decorator metadata for tests
-DummyTool._tool_run_method = DummyTool().run
-DummyTool._tool_name = DummyTool.name
-
-
-def test_generate_schema_success():
-    generator = OpenAISchemaGenerator()
-    tool = DummyTool
-    schema = generator.generate_schema(tool)
-    assert schema["name"] == tool.name
-    assert "foo" in schema["parameters"]["properties"]
-    assert "bar" in schema["parameters"]["properties"]
-    assert schema["parameters"]["properties"]["foo"]["type"] == "string"
-    assert schema["parameters"]["properties"]["bar"]["type"] == "integer"
-    assert schema["description"].startswith("Dummy tool for testing.")
-
-
-def test_generate_schema_missing_type():
-    class BadTool:
-        """
-        Args:
-            foo (str): Foo parameter.
-        Returns:
-            String result.
-        """
-
-        name = "bad_tool"
-
-        def run(self, foo):
-            return str(foo)
-
-    BadTool._tool_run_method = BadTool().run
-    BadTool._tool_name = BadTool.name
-    generator = OpenAISchemaGenerator()
-    with pytest.raises(ValueError):
-        generator.generate_schema(BadTool)
-
-
-def test_generate_schema_missing_doc():
-    class BadTool2:
-        """
-        Args:
-            foo (str): Foo parameter.
-        Returns:
-            String result.
-        """
-
-        name = "bad_tool2"
-
-        def run(self, foo: str, bar: int) -> str:
-            return str(foo)
-
-    BadTool2._tool_run_method = BadTool2().run
-    BadTool2._tool_name = BadTool2.name
-    generator = OpenAISchemaGenerator()
-    with pytest.raises(ValueError):
-        generator.generate_schema(BadTool2)
-
-
-def test_generate_schema_requires_metadata():
-    class NotRegisteredTool:
-        def run(self, foo: str) -> str:
-            return foo
-
-    generator = OpenAISchemaGenerator()
-    with pytest.raises(ValueError):
-        generator.generate_schema(NotRegisteredTool)

janito/agent/tests/__init__.py

@@ -1 +0,0 @@
-# Makes this directory a package for test discovery

janito/agent/tool_base.py

@@ -1,63 +0,0 @@
-from abc import ABC, abstractmethod
-
-
-class ToolBase(ABC):
-    """
-    Base class for all tools. Inherit from this class to implement a new tool.
-    """
-
-    def __init__(self):
-        self.progress_messages = []
-        self._progress_callback = None  # Will be set by ToolHandler if available
-
-    def report_stdout(self, message: str):
-        self.update_progress({"type": "stdout", "message": message})
-
-    def report_stderr(self, message: str):
-        self.update_progress({"type": "stderr", "message": message})
-
-    @abstractmethod
-    def run(self, **kwargs):
-        """
-        Abstract call method for tool execution. Should be overridden by subclasses.
-
-        Args:
-            **kwargs: Arbitrary keyword arguments for the tool.
-
-        Returns:
-            Any: The result of the tool execution.
-        """
-        pass
-
-    def update_progress(self, progress: dict):
-        """
-        Report progress. Subclasses can override this to customize progress reporting.
-        """
-        self.progress_messages.append(progress)
-        if hasattr(self, "_progress_callback") and self._progress_callback:
-            self._progress_callback(progress)
-
-    def report_info(self, action_type, message: str):
-        self.update_progress(
-            {
-                "type": "info",
-                "tool": self.__class__.__name__,
-                "action_type": action_type,
-                "message": message,
-            }
-        )
-
-    def report_success(self, message: str):
-        self.update_progress(
-            {"type": "success", "tool": self.__class__.__name__, "message": message}
-        )
-
-    def report_error(self, message: str):
-        self.update_progress(
-            {"type": "error", "tool": self.__class__.__name__, "message": message}
-        )
-
-    def report_warning(self, message: str):
-        self.update_progress(
-            {"type": "warning", "tool": self.__class__.__name__, "message": message}
-        )

janito/agent/tool_executor.py

@@ -1,122 +0,0 @@
-# janito/agent/tool_executor.py
-"""
-ToolExecutor: Responsible for executing tools, validating arguments, handling errors, and reporting progress.
-"""
-
-from janito.i18n import tr
-import inspect
-from janito.agent.tool_base import ToolBase
-from janito.agent.runtime_config import runtime_config
-
-
-class ToolExecutor:
-    def __init__(self, message_handler=None):
-        self.message_handler = message_handler
-
-    def execute(self, tool_entry, tool_call, arguments):
-        import uuid
-
-        call_id = getattr(tool_call, "id", None)
-        if call_id is None:
-            raise ValueError("Tool call is missing required 'id' from server.")
-        func = tool_entry["function"]
-        args = arguments
-        if runtime_config.get("no_tools_tracking", False):
-            tool_call_reason = None
-        else:
-            tool_call_reason = args.pop(
-                "tool_call_reason", None
-            )  # Extract and remove 'tool_call_reason' if present
-
-        self._maybe_log_tool_call(tool_call, args, tool_call_reason)
-        instance = self._maybe_set_progress_callback(func)
-        self._emit_tool_call_event(tool_call, call_id, args, tool_call_reason)
-        self._validate_arguments(func, args, tool_call, call_id, tool_call_reason)
-        try:
-            result = func(**args)
-            self._emit_tool_result_event(tool_call, call_id, result, tool_call_reason)
-            self._record_tool_usage(tool_call, args, result)
-            return result
-        except Exception as e:
-            self._emit_tool_error_event(tool_call, call_id, str(e), tool_call_reason)
-            raise
-
-    def _maybe_log_tool_call(self, tool_call, args, tool_call_reason):
-        verbose = runtime_config.get("verbose", False)
-        if verbose:
-            print(
-                tr(
-                    "[ToolExecutor] {tool_name} called with arguments: {args}",
-                    tool_name=tool_call.function.name,
-                    args=args,
-                )
-            )
-        if runtime_config.get("verbose_reason", False) and tool_call_reason:
-            print(
-                tr(
-                    "[ToolExecutor] Reason for call: {tool_call_reason}",
-                    tool_call_reason=tool_call_reason,
-                )
-            )
-
-    def _maybe_set_progress_callback(self, func):
-        instance = None
-        if hasattr(func, "__self__") and isinstance(func.__self__, ToolBase):
-            instance = func.__self__
-            if self.message_handler:
-                instance._progress_callback = self.message_handler.handle_message
-        return instance
-
-    def _emit_tool_call_event(self, tool_call, call_id, args, tool_call_reason):
-        if self.message_handler:
-            event = {
-                "type": "tool_call",
-                "tool": tool_call.function.name,
-                "call_id": call_id,
-                "arguments": args,
-            }
-            if tool_call_reason and not runtime_config.get("no_tools_tracking", False):
-                event["tool_call_reason"] = tool_call_reason
-            self.message_handler.handle_message(event)
-
-    def _validate_arguments(self, func, args, tool_call, call_id, tool_call_reason):
-        sig = inspect.signature(func)
-        try:
-            sig.bind(**args)
-        except TypeError as e:
-            error_msg = f"Argument validation error for tool '{tool_call.function.name}': {str(e)}"
-            self._emit_tool_error_event(tool_call, call_id, error_msg, tool_call_reason)
-            raise TypeError(error_msg)
-
-    def _emit_tool_result_event(self, tool_call, call_id, result, tool_call_reason):
-        if self.message_handler:
-            result_event = {
-                "type": "tool_result",
-                "tool": tool_call.function.name,
-                "call_id": call_id,
-                "result": result,
-            }
-            if tool_call_reason and not runtime_config.get("no_tools_tracking", False):
-                result_event["tool_call_reason"] = tool_call_reason
-            self.message_handler.handle_message(result_event)
-
-    def _emit_tool_error_event(self, tool_call, call_id, error, tool_call_reason):
-        if self.message_handler:
-            error_event = {
-                "type": "tool_error",
-                "tool": tool_call.function.name,
-                "call_id": call_id,
-                "error": error,
-            }
-            if tool_call_reason and not runtime_config.get("no_tools_tracking", False):
-                error_event["tool_call_reason"] = tool_call_reason
-            self.message_handler.handle_message(error_event)
-
-    def _record_tool_usage(self, tool_call, args, result):
-        try:
-            from janito.agent.tool_use_tracker import ToolUseTracker
-
-            ToolUseTracker().record(tool_call.function.name, dict(args), result)
-        except Exception as e:
-            if runtime_config.get("verbose", False):
-                print(f"[ToolExecutor] ToolUseTracker record failed: {e}")

janito/agent/tool_registry.py

@@ -1,49 +0,0 @@
-# janito/agent/tool_registry.py
-from janito.agent.tool_base import ToolBase
-from janito.agent.openai_schema_generator import OpenAISchemaGenerator
-
-_tool_registry = {}
-
-
-def register_tool(tool=None, *, name: str = None):
-    if tool is None:
-        return lambda t: register_tool(t, name=name)
-    override_name = name
-    if not (isinstance(tool, type) and issubclass(tool, ToolBase)):
-        raise TypeError("Tool must be a class derived from ToolBase.")
-    instance = tool()
-    if not hasattr(instance, "run") or not callable(instance.run):
-        raise TypeError(
-            f"Tool '{tool.__name__}' must implement a callable 'call' method."
-        )
-    tool_name = override_name or instance.name
-    # Add metadata for schema generation
-    tool._tool_run_method = instance.run
-    tool._tool_name = tool_name
-    if tool_name in _tool_registry:
-        raise ValueError(f"Tool '{tool_name}' is already registered.")
-    schema = OpenAISchemaGenerator().generate_schema(tool)
-    _tool_registry[tool_name] = {
-        "function": instance.run,
-        "description": schema["description"],
-        "parameters": schema["parameters"],
-        "class": tool,
-        "instance": instance,
-    }
-    return tool
-
-
-def get_tool_schemas():
-    schemas = []
-    for name, entry in _tool_registry.items():
-        schemas.append(
-            {
-                "type": "function",
-                "function": {
-                    "name": name,
-                    "description": entry["description"],
-                    "parameters": entry["parameters"],
-                },
-            }
-        )
-    return schemas

janito/agent/tools/__init__.py

@@ -1,47 +0,0 @@
-from . import ask_user
-from . import create_directory
-from . import create_file
-from . import replace_file
-from . import fetch_url
-from . import open_url
-from . import find_files
-from . import get_lines
-from .get_file_outline import core  # noqa: F401,F811
-from . import move_file
-from .validate_file_syntax import core  # noqa: F401,F811
-from . import remove_directory
-from . import remove_file
-from . import replace_text_in_file
-from . import delete_text_in_file
-from . import run_bash_command
-from . import run_powershell_command
-from . import present_choices
-from . import search_text
-from . import python_command_runner
-from . import python_file_runner
-from . import python_stdin_runner
-
-__all__ = [
-    "ask_user",
-    "create_directory",
-    "create_file",
-    "fetch_url",
-    "open_url",
-    "find_files",
-    "GetFileOutlineTool",
-    "get_lines",
-    "move_file",
-    "validate_file_syntax",
-    "remove_directory",
-    "remove_file",
-    "replace_file",
-    "replace_text_in_file",
-    "delete_text_in_file",
-    "run_bash_command",
-    "run_powershell_command",
-    "present_choices",
-    "search_text",
-    "python_command_runner",
-    "python_file_runner",
-    "python_stdin_runner",
-]

janito/agent/tools/create_file.py

@@ -1,59 +0,0 @@
-import os
-from janito.agent.tool_registry import register_tool
-
-# from janito.agent.tools_utils.expand_path import expand_path
-from janito.agent.tools_utils.utils import display_path
-from janito.agent.tool_base import ToolBase
-from janito.agent.tools_utils.action_type import ActionType
-from janito.i18n import tr
-
-
-from janito.agent.tools.validate_file_syntax.core import validate_file_syntax
-
-
-@register_tool(name="create_file")
-class CreateFileTool(ToolBase):
-    """
-    Create a new file with the given content.
-    Args:
-        file_path (str): Path to the file to create.
-        content (str): Content to write to the file.
-    Returns:
-        str: Status message indicating the result. Example:
-            - "✅ Successfully created the file at ..."
-
-    Note: Syntax validation is automatically performed after this operation.
-    """
-
-    def run(self, file_path: str, content: str) -> str:
-        expanded_file_path = file_path  # Using file_path as is
-        disp_path = display_path(expanded_file_path)
-        file_path = expanded_file_path
-        if os.path.exists(file_path):
-            try:
-                with open(file_path, "r", encoding="utf-8", errors="replace") as f:
-                    existing_content = f.read()
-            except Exception as e:
-                existing_content = f"[Error reading file: {e}]"
-            return tr(
-                "❗ Cannot create file: file already exists at '{disp_path}'.\n--- Current file content ---\n{existing_content}",
-                disp_path=disp_path,
-                existing_content=existing_content,
-            )
-        dir_name = os.path.dirname(file_path)
-        if dir_name:
-            os.makedirs(dir_name, exist_ok=True)
-        self.report_info(
-            ActionType.WRITE,
-            tr("📝 Create file '{disp_path}' ...", disp_path=disp_path),
-        )
-        with open(file_path, "w", encoding="utf-8", errors="replace") as f:
-            f.write(content)
-        new_lines = content.count("\n") + 1 if content else 0
-        self.report_success(tr("✅ {new_lines} lines", new_lines=new_lines))
-        # Perform syntax validation and append result
-        validation_result = validate_file_syntax(file_path)
-        return (
-            tr("✅ Created file {new_lines} lines.", new_lines=new_lines)
-            + f"\n{validation_result}"
-        )