janito 1.9.0__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(f"  {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

@@ -6,9 +6,10 @@ You will be developing and testing in the following environment:
  Shell/Environment: {{ shell_info }}
 
 Respond according to the following guidelines:
-  - Before answering check for files in the current project that might be related to the question
+  - Before answering check for files that might be related to the question
   - Before using your namespace functions, provide a concise explanation.
-  - When you are likely to need the entire file content, get the full content by omitting range numbers
-  - Do not provide the code in the messages, use the namespace functions to provide the cocde changes.
+  - 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.
-  - When locating code lines to change, check the surrounding lines content for indentation precise replacement.
+  - 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

@@ -16,7 +16,9 @@ class ToolExecutor:
     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 = arguments
         if runtime_config.get("no_tools_tracking", False):
@@ -25,15 +27,21 @@ class ToolExecutor:
             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
 
-            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(
@@ -50,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",
@@ -66,52 +78,45 @@ class ToolExecutor:
             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 and not runtime_config.get(
-                    "no_tools_tracking", False
-                ):
-                    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 and not runtime_config.get(
-                    "no_tools_tracking", False
-                ):
-                    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 and not runtime_config.get(
-                    "no_tools_tracking", False
-                ):
-                    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

janito/agent/tools/__init__.py

@@ -14,9 +14,11 @@ from . import replace_text_in_file
 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",
@@ -35,8 +37,9 @@ __all__ = [
     "delete_text_in_file",
     "run_bash_command",
     "run_powershell_command",
-    "run_python_command",
-    "search_files",
     "present_choices",
     "search_text",
+    "python_command_runner",
+    "python_file_runner",
+    "python_stdin_runner",
 ]

janito/agent/tools/create_directory.py

@@ -3,6 +3,7 @@ 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
 import os
 
@@ -24,7 +25,8 @@ class CreateDirectoryTool(ToolBase):
         # 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):

janito/agent/tools/create_file.py

@@ -4,6 +4,7 @@ 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
 
 
@@ -20,6 +21,8 @@ class CreateFileTool(ToolBase):
     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:
@@ -40,7 +43,10 @@ class CreateFileTool(ToolBase):
         dir_name = os.path.dirname(file_path)
         if dir_name:
             os.makedirs(dir_name, exist_ok=True)
-        self.report_info(tr("📝 Creating file '{disp_path}' ...", disp_path=disp_path))
+        self.report_info(
+            ActionType.WRITE,
+            tr("📝 Creating 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

janito/agent/tools/fetch_url.py

@@ -2,6 +2,7 @@ import requests
 from bs4 import BeautifulSoup
 from janito.agent.tool_registry import register_tool
 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_utils.utils import pluralize
 
@@ -24,9 +25,45 @@ class FetchUrlTool(ToolBase):
         if not url.strip():
             self.report_warning(tr("ℹ️ Empty URL provided."))
             return tr("Warning: Empty URL provided. Operation skipped.")
-        self.report_info(tr("🌐 Fetching URL '{url}' ...", url=url))
-        response = requests.get(url, timeout=10)
-        response.raise_for_status()
+        self.report_info(ActionType.READ, tr("🌐 Fetching URL '{url}' ...", url=url))
+        try:
+            response = requests.get(url, timeout=10)
+            response.raise_for_status()
+        except requests.exceptions.HTTPError as http_err:
+            status_code = http_err.response.status_code if http_err.response else None
+            if status_code and 400 <= status_code < 500:
+                self.report_error(
+                    tr(
+                        "❗ HTTP {status_code} error for URL: {url}",
+                        status_code=status_code,
+                        url=url,
+                    )
+                )
+                return tr(
+                    "Warning: HTTP {status_code} error for URL: {url}",
+                    status_code=status_code,
+                    url=url,
+                )
+            else:
+                self.report_error(
+                    tr(
+                        "❗ HTTP error for URL: {url}: {err}",
+                        url=url,
+                        err=str(http_err),
+                    )
+                )
+                return tr(
+                    "Warning: HTTP error for URL: {url}: {err}",
+                    url=url,
+                    err=str(http_err),
+                )
+        except Exception as err:
+            self.report_error(
+                tr("❗ Error fetching URL: {url}: {err}", url=url, err=str(err))
+            )
+            return tr(
+                "Warning: Error fetching URL: {url}: {err}", url=url, err=str(err)
+            )
         self.update_progress(
             {
                 "event": "progress",

janito/agent/tools/find_files.py

@@ -1,4 +1,5 @@
 from janito.agent.tool_base import ToolBase
+from janito.agent.tools_utils.action_type import ActionType
 from janito.agent.tool_registry import register_tool
 from janito.agent.tools_utils.utils import pluralize, display_path
 from janito.agent.tools_utils.dir_walk_utils import walk_dir_with_gitignore
@@ -38,12 +39,13 @@ class FindFilesTool(ToolBase):
                 else ""
             )
             self.report_info(
+                ActionType.READ,
                 tr(
                     "🔍 Searching for files '{pattern}' in '{disp_path}'{depth_msg} ...",
                     pattern=pattern,
                     disp_path=disp_path,
                     depth_msg=depth_msg,
-                )
+                ),
             )
             dir_output = set()
             for root, dirs, files in walk_dir_with_gitignore(