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

janito/agent/profile_manager.py

@@ -1,152 +1,68 @@
-from janito.agent.conversation import ConversationHandler
 from openai import OpenAI
-import jinja2
+from jinja2 import Environment, FileSystemLoader, select_autoescape
 from pathlib import Path
-import platform
-import os
+from janito.agent.platform_discovery import get_platform_name, get_python_version
+from janito.agent.platform_discovery import detect_shell
 
 
 class AgentProfileManager:
     REFERER = "www.janito.dev"
     TITLE = "Janito"
 
-    def parse_style_string(self, style: str):
-        if "-" in style:
-            parts = style.split("-")
-            return parts[0], parts[1:]
-        return style, []
-
-    def get_platform_name(self):
-        sys_platform = platform.system().lower()
-        if sys_platform.startswith("win"):
-            return "windows"
-        elif sys_platform.startswith("linux"):
-            return "linux"
-        elif sys_platform.startswith("darwin"):
-            return "darwin"
-        return sys_platform
-
-    def get_python_version(self):
-        return platform.python_version()
-
-    def get_shell_info(self):
-        shell = os.environ.get("SHELL")
-        term = os.environ.get("TERM")
-        term_program = os.environ.get("TERM_PROGRAM")
-        if shell:
-            info = shell
-        elif os.environ.get("MSYSTEM"):
-            info = f"Git Bash ({os.environ.get('MSYSTEM')})"
-        elif os.environ.get("WSL_DISTRO_NAME"):
-            info = f"WSL ({os.environ.get('WSL_DISTRO_NAME')})"
-        else:
-            comspec = os.environ.get("COMSPEC")
-            if comspec:
-                if "powershell" in comspec.lower():
-                    info = "PowerShell"
-                elif "cmd" in comspec.lower():
-                    info = "cmd.exe"
-                else:
-                    info = "Unknown shell"
-            else:
-                info = "Unknown shell"
-        if term:
-            info += f", TERM={term}"
-        if term_program and term_program.lower() == "vscode":
-            info += ", running in VSCode"
-        home_dir = os.path.expanduser("~")
-        if home_dir:
-            info += f", HOME={home_dir}"
-        return info
-        return "unknown"
+    def set_role(self, new_role):
+        """Set the agent's role and force prompt re-rendering."""
+        self.role = new_role
+        self.refresh_prompt()
 
     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"
-        features_dir = base_dir / "features"
-        loader = jinja2.ChoiceLoader(
-            [
-                jinja2.FileSystemLoader(str(profiles_dir)),
-                jinja2.FileSystemLoader(str(features_dir)),
-            ]
-        )
-        env = jinja2.Environment(loader=loader)
-        if main_style == "technical":
-            main_template = "system_prompt_template_technical.j2"
+        if getattr(self, "lang", "en") == "pt":
+            main_template_name = "system_prompt_template_base_pt.txt.j2"
         else:
-            main_template = "system_prompt_template.j2"
-        platform_name = self.get_platform_name()
-        python_version = self.get_python_version()
-        shell_info = self.get_shell_info()
-        if not features:
-            # Inject tech.txt existence and content
-            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."
-            template = env.get_template(main_template)
-            return template.render(
-                role=self.role,
-                interaction_mode=self.interaction_mode,
-                platform=platform_name,
-                python_version=python_version,
-                shell_info=shell_info,
-                tech_txt_exists=tech_txt_exists,
-                tech_txt_content=tech_txt_content,
-            )
-        parent_template = main_template
-        # Inject tech.txt existence and content for feature templates as well
-        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."
+            main_template_name = "system_prompt_template_base.txt.j2"
+        platform_name = get_platform_name()
+        python_version = get_python_version()
+        shell_info = detect_shell()
+
         context = {
             "role": self.role,
             "interaction_mode": self.interaction_mode,
             "platform": platform_name,
             "python_version": python_version,
             "shell_info": shell_info,
-            "tech_txt_exists": tech_txt_exists,
-            "tech_txt_content": tech_txt_content,
         }
-        for feature in features:
-            feature_template = f"system_prompt_template_{feature}.j2"
-            template = env.get_template(feature_template)
-            context["parent_template"] = parent_template
-            rendered = template.render(**context)
-            parent_template = feature_template
-        return rendered
+        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__(
         self,
         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
 
@@ -161,7 +77,15 @@ class AgentProfileManager:
                 api_key=api_key,
                 default_headers={"HTTP-Referer": self.REFERER, "X-Title": self.TITLE},
             )
-        self.agent = ConversationHandler(self.client, model)
+        from janito.agent.openai_client import Agent
+
+        self.agent = Agent(
+            api_key=api_key,
+            model=model,
+            base_url=base_url,
+            use_azure_openai=use_azure_openai,
+            azure_openai_api_version=azure_openai_api_version,
+        )
         self.system_prompt_template = None
 
     def refresh_prompt(self):

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,10 +1,11 @@
 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:
+class RichMessageHandler(MessageHandlerProtocol):
     """
     Unified message handler for all output (tool, agent, system) using Rich for styled output.
     """
@@ -31,6 +32,7 @@ class RichMessageHandler:
 
         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":

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

janito/agent/tool_use_tracker.py

@@ -0,0 +1,46 @@
+import threading
+from typing import Any, Dict, List
+
+
+class ToolUseTracker:
+    _instance = None
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        if not cls._instance:
+            with cls._lock:
+                if not cls._instance:
+                    cls._instance = super().__new__(cls)
+                    cls._instance._history = []
+        return cls._instance
+
+    def record(self, tool_name: str, params: Dict[str, Any]):
+        self._history.append({"tool": tool_name, "params": params})
+
+    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]]:
+        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)
+        return ops
+
+    def file_fully_read(self, file_path: str) -> bool:
+        for entry in self._history:
+            if entry["tool"] == "get_lines":
+                params = entry["params"]
+                if params.get("file_path") == file_path:
+                    # If both from_line and to_line are None, full file was read
+                    if (
+                        params.get("from_line") is None
+                        and params.get("to_line") is None
+                    ):
+                        return True
+        return False
+
+    @classmethod
+    def instance(cls):
+        return cls()

janito/agent/tools/__init__.py

@@ -3,20 +3,20 @@ from . import create_directory
 from . import create_file
 from . import fetch_url
 from . import find_files
-from . import get_file_outline
 from . import get_lines
+from . import outline_file
 from . import gitignore_utils
 from . import move_file
-from . import py_compile_file
+from . import validate_file_syntax
 from . import remove_directory
 from . import remove_file
 from . import replace_text_in_file
 from . import rich_live
 from . import run_bash_command
+from . import run_powershell_command
 from . import run_python_command
-from . import search_files
-from . import tools_utils
-from . import replace_file
+from . import present_choices
+from . import search_text
 
 __all__ = [
     "ask_user",
@@ -24,18 +24,21 @@ __all__ = [
     "create_file",
     "fetch_url",
     "find_files",
-    "get_file_outline",
+    "outline_file",
     "get_lines",
     "gitignore_utils",
     "move_file",
-    "py_compile_file",
+    "validate_file_syntax",
     "remove_directory",
     "remove_file",
     "replace_text_in_file",
     "rich_live",
     "run_bash_command",
+    "run_powershell_command",
     "run_python_command",
     "search_files",
     "tools_utils",
-    "replace_file",
+    "memory",
+    "present_choices",
+    "search_text",
 ]