janito 1.7.0__py3-none-any.whl → 1.8.0__py3-none-any.whl

janito/agent/profile_manager.py

@@ -1,21 +1,11 @@
 from openai import OpenAI
-import toml
-from string import Template
+from jinja2 import Environment, FileSystemLoader, select_autoescape
 from pathlib import Path
 from janito.agent.platform_discovery import get_platform_name, get_python_version
 from janito.agent.platform_discovery import detect_shell
 
 
 class AgentProfileManager:
-    def _report_template_not_found(self, template_name, search_dirs):
-        import sys
-
-        search_dirs_str = ", ".join(str(d) for d in search_dirs)
-        print(
-            f"❗ TemplateNotFound: '{template_name}'\n  Searched paths: {search_dirs_str}",
-            file=sys.stderr,
-        )
-
     REFERER = "www.janito.dev"
     TITLE = "Janito"
 
@@ -24,90 +14,30 @@ class AgentProfileManager:
         self.role = new_role
         self.refresh_prompt()
 
-    def parse_style_string(self, style: str):
-        if "-" in style:
-            parts = style.split("-")
-            return parts[0], parts[1:]
-        return style, []
-
     def render_prompt(self):
-        main_style, features = self.parse_style_string(self.interaction_style)
         base_dir = Path(__file__).parent / "templates"
         profiles_dir = base_dir / "profiles"
-        # Determine which TOML profile to use
-        if main_style == "technical":
-            main_template = profiles_dir / "system_prompt_template_technical.toml"
+        if getattr(self, "lang", "en") == "pt":
+            main_template_name = "system_prompt_template_base_pt.txt.j2"
         else:
-            main_template = profiles_dir / "system_prompt_template_default.toml"
-        # Gather context variables
+            main_template_name = "system_prompt_template_base.txt.j2"
         platform_name = get_platform_name()
         python_version = get_python_version()
         shell_info = detect_shell()
-        tech_txt_path = Path(".janito") / "tech.txt"
-        tech_txt_exists = tech_txt_path.exists()
-        tech_txt_content = ""
-        if tech_txt_exists:
-            try:
-                tech_txt_content = tech_txt_path.read_text(encoding="utf-8")
-            except Exception:
-                tech_txt_content = "⚠️ Error reading janito/tech.txt."
+
         context = {
             "role": self.role,
             "interaction_mode": self.interaction_mode,
             "platform": platform_name,
             "python_version": python_version,
             "shell_info": shell_info,
-            "tech_txt_exists": str(tech_txt_exists),
-            "tech_txt_content": tech_txt_content,
         }
-
-        # Load and merge TOML templates (handle inheritance)
-        def load_toml_with_inheritance(path):
-            data = toml.load(path)
-            if "extends" in data:
-                base_path = profiles_dir / data["extends"]
-                base_data = toml.load(base_path)
-                base_data.update({k: v for k, v in data.items() if k != "extends"})
-                return base_data
-            return data
-
-        toml_data = load_toml_with_inheritance(main_template)
-        # Merge in feature-specific TOML if any
-        for feature in features:
-            feature_template = profiles_dir / f"system_prompt_template_{feature}.toml"
-            if feature_template.exists():
-                feature_data = toml.load(feature_template)
-                toml_data.update(
-                    {k: v for k, v in feature_data.items() if k != "extends"}
-                )
-
-        # Render the TOML structure as a prompt string
-        def render_section(section):
-            if isinstance(section, dict):
-                out = []
-                for k, v in section.items():
-                    if isinstance(v, list):
-                        out.append(f"{k}:")
-                        for item in v:
-                            out.append(f"  - {item}")
-                    else:
-                        out.append(f"{k}: {v}")
-                return "\n".join(out)
-            elif isinstance(section, list):
-                return "\n".join(f"- {item}" for item in section)
-            else:
-                return str(section)
-
-        prompt_sections = []
-        for section, value in toml_data.items():
-            if section == "extends":
-                continue
-            prompt_sections.append(f"[{section}]")
-            prompt_sections.append(render_section(value))
-            prompt_sections.append("")
-        prompt_template = "\n".join(prompt_sections)
-        # Substitute variables
-        prompt = Template(prompt_template).safe_substitute(context)
+        env = Environment(
+            loader=FileSystemLoader(str(profiles_dir)),
+            autoescape=select_autoescape(["txt", "j2"]),
+        )
+        template = env.get_template(main_template_name)
+        prompt = template.render(**context)
         return prompt
 
     def __init__(
@@ -115,22 +45,24 @@ class AgentProfileManager:
         api_key,
         model,
         role,
-        interaction_style,
+        profile_name,
         interaction_mode,
         verbose_tools,
         base_url,
         azure_openai_api_version,
         use_azure_openai,
+        lang="en",
     ):
         self.api_key = api_key
         self.model = model
         self.role = role
-        self.interaction_style = interaction_style
+        self.profile_name = "base"
         self.interaction_mode = interaction_mode
         self.verbose_tools = verbose_tools
         self.base_url = base_url
         self.azure_openai_api_version = azure_openai_api_version
         self.use_azure_openai = use_azure_openai
+        self.lang = lang
         if use_azure_openai:
             from openai import AzureOpenAI
 

janito/agent/queued_message_handler.py

@@ -1,3 +1,6 @@
+from janito.i18n import tr
+
+
 class QueuedMessageHandler:
     def __init__(self, queue, *args, **kwargs):
         self._queue = queue
@@ -6,17 +9,33 @@ class QueuedMessageHandler:
         # Unified: send content (agent/LLM) messages to the frontend via queue
         if not isinstance(msg, dict):
             raise TypeError(
-                f"QueuedMessageHandler.handle_message expects a dict with 'type' and 'message', got {type(msg)}: {msg!r}"
+                tr(
+                    "QueuedMessageHandler.handle_message expects a dict with 'type' and 'message', got {msg_type}: {msg!r}",
+                    msg_type=type(msg),
+                    msg=msg,
+                )
             )
         msg_type = msg.get("type", "info")
         # For tool_call and tool_result, print and forward the full dict
         if msg_type in ("tool_call", "tool_result"):
-            print(f"[QueuedMessageHandler] {msg_type}: {msg}")
+            print(
+                tr(
+                    "[QueuedMessageHandler] {msg_type}: {msg}",
+                    msg_type=msg_type,
+                    msg=msg,
+                )
+            )
             self._queue.put(msg)
             return
         message = msg.get("message", "")
         # For normal agent/user/info messages, emit type 'content' for frontend compatibility
-        print(f"[QueuedMessageHandler] {msg_type}: {message}")
+        print(
+            tr(
+                "[QueuedMessageHandler] {msg_type}: {message}",
+                msg_type=msg_type,
+                message=message,
+            )
+        )
         if msg_type == "content":
             self._queue.put({"type": "content", "content": message})
         elif msg_type == "info":

janito/agent/rich_message_handler.py

@@ -1,72 +1,66 @@
-from rich.console import Console
-from janito.agent.runtime_config import runtime_config, unified_config
-
-console = Console()
-
-
-class RichMessageHandler:
-    """
-    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.
-        """
-        # 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}"
-            )
-
-        msg_type = msg.get("type", "info")
-        message = msg.get("message", "")
-
-        def _remove_surrogates(text):
-            return "".join(c for c in text if not 0xD800 <= ord(c) <= 0xDFFF)
-
-        safe_message = (
-            _remove_surrogates(message) if isinstance(message, str) else message
-        )
-
-        if trust and msg_type != "content":
-            return  # Suppress all except content
-        if msg_type == "content":
-            self.console.print(Markdown(safe_message))
-        elif msg_type == "info":
-            self.console.print(safe_message, style="cyan", end="")
-        elif msg_type == "success":
-            self.console.print(safe_message, style="bold green", end="\n")
-        elif msg_type == "error":
-            self.console.print(safe_message, style="bold red", end="\n")
-        elif msg_type == "progress":
-            self._handle_progress(safe_message)
-        elif msg_type == "warning":
-            self.console.print(safe_message, style="bold yellow", end="\n")
-        elif msg_type == "stdout":
-            from rich.text import Text
-
-            self.console.print(
-                Text(safe_message, style="on #003300", no_wrap=True, overflow=None),
-                end="",
-            )
-        elif msg_type == "stderr":
-            from rich.text import Text
-
-            self.console.print(
-                Text(safe_message, style="on #330000", no_wrap=True, overflow=None),
-                end="",
-            )
-        else:
-            # Ignore unsupported message types silently
-            return
+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()
+
+
+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.
+        """
+        # 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}"
+            )
+
+        msg_type = msg.get("type", "info")
+        message = msg.get("message", "")
+
+        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

janito/agent/templates/profiles/system_prompt_template_base.txt.j2

@@ -0,0 +1,14 @@
+You are acting as: {{ role }}
+
+You have access for development purposes to 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.
+  - 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.
+

janito/agent/templates/profiles/system_prompt_template_base_pt.txt.j2

@@ -0,0 +1,13 @@
+Você está atuando como: {{ role }}
+
+Você tem acesso, para fins de desenvolvimento, ao seguinte ambiente:
+ Plataforma: {{ platform }}
+ Versão do Python: {{ python_version }}
+ Shell/Ambiente: {{ shell_info }}
+
+Responda seguindo estas diretrizes:
+  - Antes de usar suas funções de namespace, forneça uma explicação concisa.
+  - Na primeira mensagem faça uma pesquisa no projeto.
+  - Prefira fazer edições localizadas usando substituições de string. Se a alteração necessária for extensa, substitua o arquivo inteiro.
+  - Ao localizar linhas de código para alterar, consider o conteúdo das linhas anteriores para uma substituição precisa de indentação.
+  - Após editar arquivos, valide-os.

janito/agent/test_handler_protocols.py

@@ -0,0 +1,47 @@
+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/tests/__init__.py

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

janito/agent/tool_base.py

@@ -17,7 +17,7 @@ class ToolBase(ABC):
         self.update_progress({"type": "stderr", "message": message})
 
     @abstractmethod
-    def call(self, **kwargs):
+    def run(self, **kwargs):
         """
         Abstract call method for tool execution. Should be overridden by subclasses.
 

janito/agent/tool_executor.py

@@ -0,0 +1,109 @@
+# janito/agent/tool_executor.py
+"""
+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
+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):
+        import uuid
+
+        call_id = getattr(tool_call, "id", None) or str(uuid.uuid4())
+        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
+
+            ToolUseTracker().record(tool_call.function.name, dict(args))
+        except Exception as e:
+            if runtime_config.get("verbose", False):
+                print(f"[ToolExecutor] ToolUseTracker record failed: {e}")
+
+        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,
+                )
+            )
+        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
+        if self.message_handler:
+            event = {
+                "type": "tool_call",
+                "tool": tool_call.function.name,
+                "call_id": call_id,
+                "arguments": args,
+            }
+            if tool_call_reason:
+                event["tool_call_reason"] = tool_call_reason
+            self.message_handler.handle_message(event)
+        # Argument validation
+        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)
+            raise TypeError(error_msg)
+        # Execute tool
+        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
+        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

janito/agent/tool_registry.py

@@ -1,8 +1,6 @@
 # janito/agent/tool_registry.py
-import json
 from janito.agent.tool_base import ToolBase
 from janito.agent.openai_schema_generator import generate_openai_function_schema
-import inspect
 
 _tool_registry = {}
 
@@ -14,16 +12,16 @@ def register_tool(tool=None, *, name: str = None):
     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, "call") or not callable(instance.call):
+    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
     if tool_name in _tool_registry:
         raise ValueError(f"Tool '{tool_name}' is already registered.")
-    schema = generate_openai_function_schema(instance.call, tool_name, tool_class=tool)
+    schema = generate_openai_function_schema(instance.run, tool_name, tool_class=tool)
     _tool_registry[tool_name] = {
-        "function": instance.call,
+        "function": instance.run,
         "description": schema["description"],
         "parameters": schema["parameters"],
         "class": tool,
@@ -46,73 +44,3 @@ def get_tool_schemas():
             }
         )
     return schemas
-
-
-def handle_tool_call(tool_call, message_handler=None, verbose=False):
-    import uuid
-
-    call_id = getattr(tool_call, "id", None) or str(uuid.uuid4())
-    tool_entry = _tool_registry.get(tool_call.function.name)
-    if not tool_entry:
-        return f"Unknown tool: {tool_call.function.name}"
-    func = tool_entry["function"]
-    args = json.loads(tool_call.function.arguments)
-    if verbose:
-        print(f"[Tool Call] {tool_call.function.name} called with arguments: {args}")
-    instance = None
-    if hasattr(func, "__self__") and isinstance(func.__self__, ToolBase):
-        instance = func.__self__
-        if message_handler:
-            instance._progress_callback = message_handler.handle_message
-    # Emit tool_call event before calling the tool
-    if message_handler:
-        message_handler.handle_message(
-            {
-                "type": "tool_call",
-                "tool": tool_call.function.name,
-                "call_id": call_id,
-                "arguments": args,
-            }
-        )
-    # --- Argument validation start ---
-    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 message_handler:
-            message_handler.handle_message(
-                {
-                    "type": "tool_error",
-                    "tool": tool_call.function.name,
-                    "call_id": call_id,
-                    "error": error_msg,
-                }
-            )
-        raise TypeError(error_msg)
-    # --- Argument validation end ---
-    try:
-        result = func(**args)
-        if message_handler:
-            message_handler.handle_message(
-                {
-                    "type": "tool_result",
-                    "tool": tool_call.function.name,
-                    "call_id": call_id,
-                    "result": result,
-                }
-            )
-        return result
-    except Exception as e:
-        if message_handler:
-            message_handler.handle_message(
-                {
-                    "type": "tool_error",
-                    "tool": tool_call.function.name,
-                    "call_id": call_id,
-                    "error": str(e),
-                }
-            )
-        raise