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

janito/agent/tool_registry.py

@@ -1,132 +1,118 @@
-# janito/agent/tool_registry.py
-import json
-from janito.agent.tools.tool_base import ToolBase
-from janito.agent.openai_schema_generator import generate_openai_function_schema
-
-_tool_registry = {}
-
-def register_tool(tool=None, *, name: str = None):
-    if tool is None:
-        return lambda t: register_tool(t, name=name)
-    override_name = name
-    if not (isinstance(tool, type) and issubclass(tool, ToolBase)):
-        raise TypeError("Tool must be a class derived from ToolBase.")
-    instance = tool()
-    func = instance.call
-    default_name = tool.__name__
-    tool_name = override_name or default_name
-    schema = generate_openai_function_schema(func, tool_name)
-    _tool_registry[tool_name] = {
-        "function": func,
-        "description": schema["description"],
-        "parameters": schema["parameters"]
-    }
-    return tool
-
-def get_tool_schemas():
-    schemas = []
-    for name, entry in _tool_registry.items():
-        schemas.append({
-            "type": "function",
-            "function": {
-                "name": name,
-                "description": entry["description"],
-                "parameters": entry["parameters"]
-            }
-        })
-    return schemas
-
-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,
-        })
-    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
-
-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,
-            'args': args,
-            'call_id': call_id
-        })
-    try:
-        result = func(**args)
-    except Exception as e:
-        import traceback  # Kept here: only needed on error
-        error_message = f"[Tool Error] {type(e).__name__}: {e}\n" + traceback.format_exc()
-        if message_handler:
-            message_handler.handle_message({'type': 'error', 'message': error_message})
-        result = error_message
-    # Emit tool_result event after tool execution
-    if message_handler:
-        message_handler.handle_message({
-            'type': 'tool_result',
-            'tool': tool_call.function.name,
-            'call_id': call_id,
-            'result': result
-        })
-    if verbose:
-        preview = result
-        if isinstance(result, str):
-            lines = result.splitlines()
-            if len(lines) > 10:
-                preview = "\n".join(lines[:10]) + "\n... (truncated)"
-            elif len(result) > 500:
-                preview = result[:500] + "... (truncated)"
-        print(f"[Tool Result] {tool_call.function.name} returned:\n{preview}")
-    if instance is not None:
-        instance._progress_callback = None
-    return result
+# 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 = {}
+
+
+def register_tool(tool=None, *, name: str = None):
+    if tool is None:
+        return lambda t: register_tool(t, name=name)
+    override_name = name
+    if not (isinstance(tool, type) and issubclass(tool, ToolBase)):
+        raise TypeError("Tool must be a class derived from ToolBase.")
+    instance = tool()
+    if not hasattr(instance, "call") or not callable(instance.call):
+        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)
+    _tool_registry[tool_name] = {
+        "function": instance.call,
+        "description": schema["description"],
+        "parameters": schema["parameters"],
+        "class": tool,
+        "instance": instance,
+    }
+    return tool
+
+
+def get_tool_schemas():
+    schemas = []
+    for name, entry in _tool_registry.items():
+        schemas.append(
+            {
+                "type": "function",
+                "function": {
+                    "name": name,
+                    "description": entry["description"],
+                    "parameters": entry["parameters"],
+                },
+            }
+        )
+    return schemas
+
+
+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/tools/__init__.py

@@ -1,2 +1,41 @@
-# This file is intentionally empty.
-# Tool auto-imports are handled by janito.agent.tool_auto_imports at CLI startup.
+from . import ask_user
+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 gitignore_utils
+from . import move_file
+from . import py_compile_file
+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_python_command
+from . import search_files
+from . import tools_utils
+from . import replace_file
+
+__all__ = [
+    "ask_user",
+    "create_directory",
+    "create_file",
+    "fetch_url",
+    "find_files",
+    "get_file_outline",
+    "get_lines",
+    "gitignore_utils",
+    "move_file",
+    "py_compile_file",
+    "remove_directory",
+    "remove_file",
+    "replace_text_in_file",
+    "rich_live",
+    "run_bash_command",
+    "run_python_command",
+    "search_files",
+    "tools_utils",
+    "replace_file",
+]

janito/agent/tools/ask_user.py

@@ -1,23 +1,22 @@
-from janito.agent.tools.tool_base import ToolBase
+from janito.agent.tool_base import ToolBase
 from janito.agent.tool_registry import register_tool
 
+
 @register_tool(name="ask_user")
 class AskUserTool(ToolBase):
-    """Ask the user a question and return their response."""
-    def call(self, question: str) -> str:
-        """
-        Ask the user a question and return their response.
-
-        Args:
-            question (str): The question to ask the user.
+    """
+    Request clarification or input from the user whenever there is uncertainty, ambiguity, missing information, or multiple valid options. Returns the user's response as a string.
 
-        Returns:
-            str: The user's response as a string. Example:
-                - "Yes"
-                - "No"
-                - "Some detailed answer..."
-        """
+    Args:
+        question (str): The question to ask the user.
+    Returns:
+        str: The user's response as a string. Example:
+            - "Yes"
+            - "No"
+            - "Some detailed answer..."
+    """
 
+    def call(self, question: str) -> str:
         from rich import print as rich_print
         from rich.panel import Panel
         from prompt_toolkit import PromptSession
@@ -29,46 +28,57 @@ class AskUserTool(ToolBase):
         rich_print(Panel.fit(question, title="Question", style="cyan"))
 
         bindings = KeyBindings()
-        mode = {'multiline': False}
+        mode = {"multiline": False}
 
-        @bindings.add('c-r')
+        @bindings.add("c-r")
         def _(event):
             pass
 
-        style = Style.from_dict({
-            'bottom-toolbar': 'bg:#333333 #ffffff',
-            'b': 'bold',
-            'prompt': 'bold bg:#000080 #ffffff',
-        })
+        @bindings.add("f12")
+        def _(event):
+            """When F12 is pressed, send 'proceed' as input immediately."""
+            buf = event.app.current_buffer
+            buf.text = "proceed"
+            buf.validate_and_handle()
+
+        style = Style.from_dict(
+            {
+                "bottom-toolbar": "bg:#333333 #ffffff",
+                "b": "bold",
+                "prompt": "bold bg:#000080 #ffffff",
+            }
+        )
 
         def get_toolbar():
-            if mode['multiline']:
-                return HTML('<b>Multiline mode (Esc+Enter to submit). Type /single to switch.</b>')
+            f12_hint = " Press <b>F12</b> to auto-fill 'proceed' and submit."
+            if mode["multiline"]:
+                return HTML(
+                    f"<b>Multiline mode (Esc+Enter to submit). Type /single to switch.</b>{f12_hint}"
+                )
             else:
-                return HTML('<b>Single-line mode (Enter to submit). Type /multi for multiline.</b>')
+                return HTML(
+                    f"<b>Single-line mode (Enter to submit). Type /multi for multiline.</b>{f12_hint}"
+                )
 
         session = PromptSession(
             multiline=False,
             key_bindings=bindings,
             editing_mode=EditingMode.EMACS,
             bottom_toolbar=get_toolbar,
-            style=style
+            style=style,
         )
 
-        prompt_icon = HTML('<prompt>💬 </prompt>')
+        prompt_icon = HTML("<prompt>💬 </prompt>")
 
         while True:
             response = session.prompt(prompt_icon)
-            if not mode['multiline'] and response.strip() == '/multi':
-                mode['multiline'] = True
+            if not mode["multiline"] and response.strip() == "/multi":
+                mode["multiline"] = True
                 session.multiline = True
                 continue
-            elif mode['multiline'] and response.strip() == '/single':
-                mode['multiline'] = False
+            elif mode["multiline"] and response.strip() == "/single":
+                mode["multiline"] = False
                 session.multiline = False
                 continue
             else:
                 return response
-
-
-from janito.agent.tool_registry import register_tool

janito/agent/tools/create_directory.py

@@ -1,31 +1,33 @@
 from janito.agent.tool_registry import register_tool
 from janito.agent.tools.utils import expand_path, display_path
-from janito.agent.tools.tool_base import ToolBase
+from janito.agent.tool_base import ToolBase
+
 
 @register_tool(name="create_directory")
 class CreateDirectoryTool(ToolBase):
     """
     Create a new directory at the specified path.
-    """
-    def call(self, path: str, overwrite: bool = False) -> str:
-        """
-        Create a new directory at the specified path.
 
-        Args:
-            path (str): Path for the new directory.
-            overwrite (bool, optional): Whether to overwrite if the directory exists. Defaults to False.
+    Args:
+        path (str): Path for the new directory.
+        overwrite (bool, optional): Whether to overwrite if the directory exists. Defaults to False.
+    Returns:
+        str: Status message indicating the result. Example:
+            - "\u2705 Successfully created the directory at ..."
+            - "\u2757 Cannot create directory: ..."
+    """
 
-        Returns:
-            str: Status message indicating the result. Example:
-                - "✅ Successfully created the directory at ..."
-                - "❗ Cannot create directory: ..."
-        """
+    def call(self, path: str, overwrite: bool = False) -> str:
         original_path = path
         path = expand_path(path)
         disp_path = display_path(original_path, path)
+        import os
+
         if os.path.exists(path):
             if not os.path.isdir(path):
-                self.report_error(f"❌ Path '{disp_path}' exists and is not a directory.")
-                return f"❌ Path '{disp_path}' exists and is not a directory."
+                self.report_error(
+                    f"\u274c Path '{disp_path}' exists and is not a directory."
+                )
+                return f"\u274c Path '{disp_path}' exists and is not a directory."
         # Directory creation logic would go here
-        return f"✅ Successfully created the directory at '{disp_path}'."
+        return f"\u2705 Successfully created the directory at '{disp_path}'."

janito/agent/tools/create_file.py

@@ -1,52 +1,47 @@
 import os
+import shutil
 from janito.agent.tool_registry import register_tool
 from janito.agent.tools.utils import expand_path, display_path
-from janito.agent.tools.tool_base import ToolBase
+from janito.agent.tool_base import ToolBase
 from janito.agent.tools.tools_utils import pluralize
 
+
 @register_tool(name="create_file")
 class CreateFileTool(ToolBase):
     """
-    Create a new file or update an existing file with the given content.
-    """
-    def call(self, path: str, content: str, overwrite: bool = False) -> str:
-        """
-        Create or update a file with the given content.
+    Create a new file with the given content. Fails if the file already exists.
 
-        Args:
-            path (str): Path to the file to create or update.
-            content (str): Content to write to the file.
-            overwrite (bool, optional): Whether to overwrite if the file exists. Defaults to False.
+    This tool will NOT overwrite existing files. If the file already exists, the operation fails and no changes are made to the file itself.
+
+    Args:
+        path (str): Path to the file to create.
+        content (str): Content to write to the file.
+        backup (bool, optional): If True, create a backup (.bak) before returning an error if the file exists. Defaults to False.
+    Returns:
+        str: Status message indicating the result. Example:
+            - "\u2705 Successfully created the file at ..."
+            - "\u2757 Cannot create file: ..."
+    """
 
-        Returns:
-            str: Status message indicating the result. Example:
-                - "✅ Successfully created the file at ..."
-                - "❗ Cannot create file: ..."
-        """
+    def call(self, path: str, content: str, backup: bool = False) -> str:
         original_path = path
         path = expand_path(path)
-        updating = os.path.exists(path) and not os.path.isdir(path)
         disp_path = display_path(original_path, path)
         if os.path.exists(path):
             if os.path.isdir(path):
-                self.report_error("❌ Error: is a directory")
-                return f"❌ Cannot create file: '{disp_path}' is an existing directory."
-            if not overwrite:
-                self.report_error(f"❗ Error: file '{disp_path}' exists and overwrite is False")
-                return f"❗ Cannot create file: '{disp_path}' already exists and overwrite is False."
-        if updating and overwrite:
-            self.report_info(f"📝 Updating file: '{disp_path}' ... ")
-        else:
-            self.report_info(f"📝 Creating file: '{disp_path}' ... ")
-        old_lines = None
-        if updating and overwrite:
-            with open(path, "r", encoding="utf-8") as f:
-                old_lines = sum(1 for _ in f)
-        with open(path, "w", encoding="utf-8") as f:
+                self.report_error("\u274c Error: is a directory")
+                return f"\u274c Cannot create file: '{disp_path}' is an existing directory."
+            if backup:
+                shutil.copy2(path, path + ".bak")
+            self.report_error(f"\u2757 Error: file '{disp_path}' already exists")
+            return f"\u2757 Cannot create file: '{disp_path}' already exists."
+        # Ensure parent directories exist
+        dir_name = os.path.dirname(path)
+        if dir_name:
+            os.makedirs(dir_name, exist_ok=True)
+        self.report_info(f"\U0001f4dd Creating file: '{disp_path}' ... ")
+        with open(path, "w", encoding="utf-8", errors="replace") as f:
             f.write(content)
-        new_lines = content.count('\n') + 1 if content else 0
-        if old_lines is not None:
-            self.report_success(f"✅ {new_lines} {pluralize('line', new_lines)}")
-            return f"✅ Successfully updated the file at '{disp_path}' ({old_lines} > {new_lines} lines)."
-        self.report_success(f"✅ {new_lines} {pluralize('line', new_lines)}")
-        return f"✅ Successfully created the file at '{disp_path}' ({new_lines} lines)."
+        new_lines = content.count("\n") + 1 if content else 0
+        self.report_success(f"\u2705 {new_lines} {pluralize('line', new_lines)}")
+        return f"\u2705 Successfully created the file at '{disp_path}' ({new_lines} lines)."

janito/agent/tools/fetch_url.py

@@ -2,34 +2,39 @@ import requests
 from bs4 import BeautifulSoup
 from janito.agent.tool_registry import register_tool
 
-from janito.agent.tools.tool_base import ToolBase
+from janito.agent.tool_base import ToolBase
+
 
 @register_tool(name="fetch_url")
 class FetchUrlTool(ToolBase):
-    """Fetch the content of a web page and extract its text."""
-    def call(self, url: str, search_strings: list[str] = None) -> str:
-        """
-        Fetch the content of a web page and extract its text.
+    """
+    Fetch the content of a web page and extract its text.
 
-        Args:
-            url (str): The URL of the web page to fetch.
-            search_strings (list[str], optional): Strings to search for in the page content.
+    Args:
+        url (str): The URL of the web page to fetch.
+        search_strings (list[str], optional): Strings to search for in the page content.
+    Returns:
+        str: Extracted text content from the web page, or a warning message. Example:
+            - "<main text content...>"
+            - "No lines found for the provided search strings."
+            - "Warning: Empty URL provided. Operation skipped."
+    """
 
-        Returns:
-            str: Extracted text content from the web page, or a warning message. Example:
-                - "<main text content...>"
-                - "No lines found for the provided search strings."
-                - "Warning: Empty URL provided. Operation skipped."
-        """
+    def call(self, url: str, search_strings: list[str] = None) -> str:
         if not url.strip():
             self.report_warning("⚠️ Warning: Empty URL provided. Operation skipped.")
             return "Warning: Empty URL provided. Operation skipped."
         self.report_info(f"🌐 Fetching URL: {url} ... ")
         response = requests.get(url, timeout=10)
         response.raise_for_status()
-        self.update_progress({'event': 'progress', 'message': f"Fetched URL with status {response.status_code}"})
-        soup = BeautifulSoup(response.text, 'html.parser')
-        text = soup.get_text(separator='\n')
+        self.update_progress(
+            {
+                "event": "progress",
+                "message": f"Fetched URL with status {response.status_code}",
+            }
+        )
+        soup = BeautifulSoup(response.text, "html.parser")
+        text = soup.get_text(separator="\n")
 
         if search_strings:
             filtered = []
@@ -41,10 +46,9 @@ class FetchUrlTool(ToolBase):
                     snippet = text[start:end]
                     filtered.append(snippet)
             if filtered:
-                text = '\n...\n'.join(filtered)
+                text = "\n...\n".join(filtered)
             else:
                 text = "No lines found for the provided search strings."
 
         self.report_success("✅ Result")
         return text
-