janito 1.8.1__py3-none-any.whl → 1.10.0__py3-none-any.whl

janito/agent/rich_message_handler.py

@@ -5,6 +5,16 @@ 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.
@@ -18,13 +28,10 @@ class RichMessageHandler(MessageHandlerProtocol):
         Handles a dict with 'type' and 'message'.
         All messages must be dicts. Raises if not.
         """
-        # Check trust config: suppress all output except 'content' if enabled
         trust = runtime_config.get("trust")
         if trust is None:
             trust = unified_config.get("trust", False)
 
-        from rich.markdown import Markdown
-
         if not isinstance(msg, dict):
             raise TypeError(
                 f"RichMessageHandler.handle_message expects a dict with 'type' and 'message', got {type(msg)}: {msg!r}"
@@ -35,32 +42,74 @@ class RichMessageHandler(MessageHandlerProtocol):
 
         if trust and msg_type != "content":
             return  # Suppress all except content
-        if msg_type == "content":
-            self.console.print(Markdown(message))
-        elif msg_type == "info":
-            self.console.print(message, style="cyan", end="")
-        elif msg_type == "success":
-            self.console.print(message, style="bold green", end="\n")
-        elif msg_type == "error":
-            self.console.print(message, style="bold red", end="\n")
-        elif msg_type == "progress":
-            self._handle_progress(message)
-        elif msg_type == "warning":
-            self.console.print(message, style="bold yellow", end="\n")
-        elif msg_type == "stdout":
-            from rich.text import Text
-
-            self.console.print(
-                Text(message, style="on #003300", no_wrap=True, overflow=None),
-                end="",
-            )
-        elif msg_type == "stderr":
-            from rich.text import Text
 
-            self.console.print(
-                Text(message, style="on #330000", no_wrap=True, overflow=None),
-                end="",
-            )
-        else:
-            # Ignore unsupported message types silently
-            return
+        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/templates/profiles/system_prompt_template_base.txt.j2

@@ -1,14 +1,15 @@
-You are acting as: {{ role }}
+You are: {{ role }}
 
-You have access for development purposes to the following environment:
+You will be developing and testing in the following environment:
  Platform: {{ platform }}
  Python version: {{ python_version }}
  Shell/Environment: {{ shell_info }}
 
-Answer according to the following guidelines:
-  - Start by searching for text/files in the project.
+Respond according to the following guidelines:
+  - Before answering check for files that might be related to the question
   - Before using your namespace functions, provide a concise explanation.
-  - Prefer making localized edits using string replacements. If the required change is extensive, replace the entire file instead.
-  - When locating code lines to change, consider the previous lines content for indentation precise replacement.
-  - After edting files, validate them.
-
+  - When planning to get the entire file content, set the range line numbers to None
+  - Do not provide the code in the messages, use the namespace functions to provide the code changes.
+  - Prefer making localized edits using string replacements. If the required change is extensive, replace the entire file instead, provide full content without placeholders.
+  - Before creating files search the code for the location related to the file purpose
+ - Once development or updates are finished, ensure that all new or updated packages, modules, functions, and methods

janito/agent/test_openai_schema_generator.py

@@ -0,0 +1,93 @@
+"""
+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/tool_base.py

@@ -37,9 +37,14 @@ class ToolBase(ABC):
         if hasattr(self, "_progress_callback") and self._progress_callback:
             self._progress_callback(progress)
 
-    def report_info(self, message: str):
+    def report_info(self, action_type, message: str):
         self.update_progress(
-            {"type": "info", "tool": self.__class__.__name__, "message": message}
+            {
+                "type": "info",
+                "tool": self.__class__.__name__,
+                "action_type": action_type,
+                "message": message,
+            }
         )
 
     def report_success(self, message: str):

janito/agent/tool_executor.py

@@ -3,7 +3,6 @@
 ToolExecutor: Responsible for executing tools, validating arguments, handling errors, and reporting progress.
 """
 
-import json
 from janito.i18n import tr
 import inspect
 from janito.agent.tool_base import ToolBase
@@ -14,24 +13,35 @@ class ToolExecutor:
     def __init__(self, message_handler=None):
         self.message_handler = message_handler
 
-    def execute(self, tool_entry, tool_call):
+    def execute(self, tool_entry, tool_call, arguments):
         import uuid
 
-        call_id = getattr(tool_call, "id", None) or str(uuid.uuid4())
+        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 = json.loads(tool_call.function.arguments)
-        tool_call_reason = args.pop(
-            "tool_call_reason", None
-        )  # Extract and remove 'tool_call_reason' if present
-        # Record tool usage
-        try:
-            from janito.agent.tool_use_tracker import ToolUseTracker
+        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
 
-            ToolUseTracker().record(tool_call.function.name, dict(args))
+        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:
-            if runtime_config.get("verbose", False):
-                print(f"[ToolExecutor] ToolUseTracker record failed: {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(
@@ -48,12 +58,16 @@ class ToolExecutor:
                     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
-        # Emit tool_call event before calling the tool
+        return instance
+
+    def _emit_tool_call_event(self, tool_call, call_id, args, tool_call_reason):
         if self.message_handler:
             event = {
                 "type": "tool_call",
@@ -61,49 +75,48 @@ class ToolExecutor:
                 "call_id": call_id,
                 "arguments": args,
             }
-            if tool_call_reason:
+            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)
-        # Argument validation
+
+    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)}"
-            if self.message_handler:
-                error_event = {
-                    "type": "tool_error",
-                    "tool": tool_call.function.name,
-                    "call_id": call_id,
-                    "error": error_msg,
-                }
-                if tool_call_reason:
-                    error_event["tool_call_reason"] = tool_call_reason
-                self.message_handler.handle_message(error_event)
+            self._emit_tool_error_event(tool_call, call_id, error_msg, tool_call_reason)
             raise TypeError(error_msg)
-        # Execute tool
+
+    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:
-            result = func(**args)
-            if self.message_handler:
-                result_event = {
-                    "type": "tool_result",
-                    "tool": tool_call.function.name,
-                    "call_id": call_id,
-                    "result": result,
-                }
-                if tool_call_reason:
-                    result_event["tool_call_reason"] = tool_call_reason
-                self.message_handler.handle_message(result_event)
-            return result
+            from janito.agent.tool_use_tracker import ToolUseTracker
+
+            ToolUseTracker().record(tool_call.function.name, dict(args), result)
         except Exception as e:
-            if self.message_handler:
-                error_event = {
-                    "type": "tool_error",
-                    "tool": tool_call.function.name,
-                    "call_id": call_id,
-                    "error": str(e),
-                }
-                if tool_call_reason:
-                    error_event["tool_call_reason"] = tool_call_reason
-                self.message_handler.handle_message(error_event)
-            raise
+            if runtime_config.get("verbose", False):
+                print(f"[ToolExecutor] ToolUseTracker record failed: {e}")

janito/agent/tool_registry.py

@@ -1,6 +1,6 @@
 # janito/agent/tool_registry.py
 from janito.agent.tool_base import ToolBase
-from janito.agent.openai_schema_generator import generate_openai_function_schema
+from janito.agent.openai_schema_generator import OpenAISchemaGenerator
 
 _tool_registry = {}
 
@@ -17,9 +17,12 @@ def register_tool(tool=None, *, name: str = None):
             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 = generate_openai_function_schema(instance.run, tool_name, tool_class=tool)
+    schema = OpenAISchemaGenerator().generate_schema(tool)
     _tool_registry[tool_name] = {
         "function": instance.run,
         "description": schema["description"],

janito/agent/tool_use_tracker.py

@@ -1,7 +1,14 @@
 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()
@@ -14,25 +21,39 @@ class ToolUseTracker:
                     cls._instance._history = []
         return cls._instance
 
-    def record(self, tool_name: str, params: Dict[str, Any]):
-        self._history.append({"tool": tool_name, "params": params})
+    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"]
-            if any(isinstance(v, str) and file_path in v for v in params.values()):
-                ops.append(entry)
+            # 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"] == "get_lines":
                 params = entry["params"]
-                if params.get("file_path") == file_path:
+                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
@@ -41,6 +62,22 @@ class ToolUseTracker:
                         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"] == "replace_file":
+            return True
+        if last["tool"] == "get_lines":
+            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/agent/tools/__init__.py

@@ -1,22 +1,24 @@
 from . import ask_user
 from . import create_directory
 from . import create_file
+from . import replace_file
 from . import fetch_url
 from . import find_files
 from . import get_lines
-from . import outline_file
-from . import gitignore_utils
+from .get_file_outline import core  # noqa: F401,F811
 from . import move_file
-from . import validate_file_syntax
+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 rich_live
+from . import delete_text_in_file
 from . import run_bash_command
 from . import run_powershell_command
-from . import run_python_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",
@@ -24,21 +26,20 @@ __all__ = [
     "create_file",
     "fetch_url",
     "find_files",
-    "outline_file",
+    "GetFileOutlineTool",
     "get_lines",
-    "gitignore_utils",
     "move_file",
     "validate_file_syntax",
     "remove_directory",
     "remove_file",
+    "replace_file",
     "replace_text_in_file",
-    "rich_live",
+    "delete_text_in_file",
     "run_bash_command",
     "run_powershell_command",
-    "run_python_command",
-    "search_files",
-    "tools_utils",
-    "memory",
     "present_choices",
     "search_text",
+    "python_command_runner",
+    "python_file_runner",
+    "python_stdin_runner",
 ]

janito/agent/tools/create_directory.py

@@ -1,6 +1,9 @@
 from janito.agent.tool_registry import register_tool
-from janito.agent.tools.utils import expand_path, display_path
+
+# 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
 import os
 
@@ -18,10 +21,12 @@ class CreateDirectoryTool(ToolBase):
     """
 
     def run(self, file_path: str) -> str:
-        file_path = expand_path(file_path)
+        # file_path = expand_path(file_path)
+        # Using file_path as is
         disp_path = display_path(file_path)
         self.report_info(
-            tr("📁 Creating directory: '{disp_path}' ...", disp_path=disp_path)
+            ActionType.WRITE,
+            tr("📁 Creating directory '{disp_path}' ...", disp_path=disp_path),
         )
         try:
             if os.path.exists(file_path):
@@ -47,9 +52,7 @@ class CreateDirectoryTool(ToolBase):
                     disp_path=disp_path,
                 )
             os.makedirs(file_path, exist_ok=True)
-            self.report_success(
-                tr("✅ Directory created at '{disp_path}'", disp_path=disp_path)
-            )
+            self.report_success(tr("✅ Directory created"))
             return tr(
                 "✅ Successfully created the directory at '{disp_path}'.",
                 disp_path=disp_path,