janito 1.3.2__py3-none-any.whl → 1.4.0__py3-none-any.whl

janito/__init__.py

@@ -1 +1 @@
-__version__ = "1.3.2"
+__version__ = "1.4.0"

janito/agent/templates/system_instructions.j2

@@ -4,6 +4,7 @@ You are an assistant for a analysis and development tool that operates on files
 directories using text-based operations.
 
 Provide a concise plan before calling any tool.
+Always execute the plan immediately after presenting it, unless the user requests otherwise.
 
 <context>
 Always review `README_structure.txt` before conducting file-specific searches.
@@ -12,25 +13,20 @@ Explore files that might be relevant to the current task.
 </context>
 
 <analysis>
-When analyzing issues, you might want to look into the git history for clues.
+In case of missing code or functions, look into the .bak files and check git diff/history for recent changes.
 </analysis>
 
 <editing>
 If in doubt during editing, use the `ask_user` function to get additional information; otherwise, proceed and inform the user of the decision made.
 
 When you need to make changes to a file, consider the following:
-
-- Use the `edit_file` tool when you want to update or fix specific text fragments within a file without altering the rest of its content. It is preferred over full file replacement when:
-    - Only small, targeted changes are needed.
-    - You want to avoid the risk of accidentally overwriting unrelated content.
-    - The file is large, and rewriting the entire file would be inefficient.
-    - You want to preserve formatting, comments, or code structure outside the replaced text.
-
+- It is preferred to replace exact text occurrences over file overwriting.
 - When replacing files, review their current content before requesting the update.
 - When reorganizing, moving files, or functions, search for references in other files that might need to be updated accordingly.
 </editing>
 
 <finishing>
+- When asked to commit and no message is provided, check the git diff and summarize the changes in the commit message.
 - Review the README content if there are user-exposed or public API changes.
 - Update `README_structure.txt` considering discovered, created, or modified files.
 </finishing>

janito/agent/tool_handler.py

@@ -1,102 +1,40 @@
 import os
 import json
 import traceback
+from janito.agent.tools.tool_base import ToolBase
 
 class ToolHandler:
     _tool_registry = {}
 
-    @classmethod
-    def register_tool(cls, func):
-        import inspect
-        import typing
-        from typing import get_origin, get_args
-
-        name = func.__name__
-        description = func.__doc__ or ""
-
-        sig = inspect.signature(func)
-        params_schema = {
-            "type": "object",
-            "properties": {},
-            "required": []
-        }
-
-        for param_name, param in sig.parameters.items():
-            if param.annotation is param.empty:
-                raise TypeError(f"Parameter '{param_name}' in tool '{name}' is missing a type hint.")
-            param_type = param.annotation
-            schema = {}
-
-            # Handle typing.Optional, typing.List, typing.Literal, etc.
-            origin = get_origin(param_type)
-            args = get_args(param_type)
-
-            if origin is typing.Union and type(None) in args:
-                # Optional[...] type
-                main_type = args[0] if args[1] is type(None) else args[1]
-                origin = get_origin(main_type)
-                args = get_args(main_type)
-                param_type = main_type
-            else:
-                main_type = param_type
-
-            if origin is list or origin is typing.List:
-                item_type = args[0] if args else str
-                item_schema = {"type": _pytype_to_json_type(item_type)}
-                schema = {"type": "array", "items": item_schema}
-            elif origin is typing.Literal:
-                schema = {"type": _pytype_to_json_type(type(args[0])), "enum": list(args)}
-            elif main_type == int:
-                schema = {"type": "integer"}
-            elif main_type == float:
-                schema = {"type": "number"}
-            elif main_type == bool:
-                schema = {"type": "boolean"}
-            elif main_type == dict:
-                schema = {"type": "object"}
-            elif main_type == list:
-                schema = {"type": "array", "items": {"type": "string"}}
-            else:
-                schema = {"type": "string"}
-
-            # Optionally add description if available in docstring (not implemented here)
-            params_schema["properties"][param_name] = schema
-            if param.default is param.empty:
-                params_schema["required"].append(param_name)
-
-        cls._tool_registry[name] = {
-            "function": func,
-            "description": description,
-            "parameters": params_schema
-        }
-        return func
-
-def _pytype_to_json_type(pytype):
-    import typing
-    if pytype == int:
-        return "integer"
-    elif pytype == float:
-        return "number"
-    elif pytype == bool:
-        return "boolean"
-    elif pytype == dict:
-        return "object"
-    elif pytype == list or pytype == typing.List:
-        return "array"
-    else:
-        return "string"
-
-class ToolHandler:
-    _tool_registry = {}
+    def __init__(self, verbose=False, enable_tools=True):
+        self.verbose = verbose
+        self.tools = []
+        self.enable_tools = enable_tools
 
     @classmethod
-    def register_tool(cls, func):
+    def register_tool(cls, tool=None, *, name: str = None):
+        """
+        Register a tool class derived from ToolBase.
+        Args:
+            tool: The tool class (must inherit from ToolBase).
+            name: Optional override for the tool name.
+        Raises:
+            TypeError: If the tool is not a subclass of ToolBase.
+        """
+        if tool is None:
+            return lambda t: cls.register_tool(t, name=name)
         import inspect
         import typing
         from typing import get_origin, get_args
 
-        name = func.__name__
-        description = func.__doc__ or ""
+        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__
+        name = override_name or default_name
+        description = tool.__doc__ or func.__doc__ or ""
 
         sig = inspect.signature(func)
         params_schema = {
@@ -143,22 +81,30 @@ class ToolHandler:
             else:
                 schema = {"type": "string"}
 
-            # Optionally add description if available in docstring (not implemented here)
+            # Add description from call method docstring if available (Google-style Args parsing)
+            if func.__doc__:
+                import re
+                doc = func.__doc__
+                args_section = re.search(r"Args:\s*(.*?)(?:\n\s*\w|Returns:|$)", doc, re.DOTALL)
+                param_descs = {}
+                if args_section:
+                    args_text = args_section.group(1)
+                    for match in re.finditer(r"(\w+) \([^)]+\): ([^\n]+)", args_text):
+                        pname, pdesc = match.groups()
+                        param_descs[pname] = pdesc.strip()
+                if param_name in param_descs:
+                    schema["description"] = param_descs[param_name]
             params_schema["properties"][param_name] = schema
             if param.default is param.empty:
                 params_schema["required"].append(param_name)
 
+        # register the bound call function
         cls._tool_registry[name] = {
             "function": func,
             "description": description,
             "parameters": params_schema
         }
-        return func
-
-    def __init__(self, verbose=False, enable_tools=True):
-        self.verbose = verbose
-        self.tools = []
-        self.enable_tools = enable_tools
+        return tool
 
     def register(self, func):
         self.tools.append(func)
@@ -194,6 +140,11 @@ class ToolHandler:
             print(f"[Tool Call] {tool_call.function.name} called with arguments: {args}")
         import inspect
         sig = inspect.signature(func)
+        # Set progress callback on tool instance if possible
+        instance = None
+        if hasattr(func, '__self__') and isinstance(func.__self__, ToolBase):
+            instance = func.__self__
+            instance._progress_callback = on_progress
         if on_progress:
             on_progress({
                 'event': 'start',
@@ -201,8 +152,6 @@ class ToolHandler:
                 'tool': tool_call.function.name,
                 'args': args
             })
-        if 'on_progress' in sig.parameters and on_progress is not None:
-            args['on_progress'] = on_progress
         try:
             result = func(**args)
         except Exception as e:
@@ -226,4 +175,22 @@ class ToolHandler:
                 'args': args,
                 'result': result
             })
+        # Clean up progress callback
+        if instance is not None:
+            instance._progress_callback = None
         return result
+
+def _pytype_to_json_type(pytype):
+    import typing
+    if pytype == int:
+        return "integer"
+    elif pytype == float:
+        return "number"
+    elif pytype == bool:
+        return "boolean"
+    elif pytype == dict:
+        return "object"
+    elif pytype == list or pytype == typing.List:
+        return "array"
+    else:
+        return "string"

janito/agent/tools/__init__.py

@@ -1,12 +1,9 @@
-from .ask_user import ask_user
-from .file_ops import create_file, create_directory, remove_file, move_file
-from .get_lines import get_lines
-from .replace_text_in_file import replace_text_in_file
-from .find_files import find_files
-from .run_bash_command import run_bash_command
-from .fetch_url import fetch_url
-from .python_exec import python_exec
-from .py_compile import py_compile_file
-from .search_files import search_files
-from .remove_directory import remove_directory
+import importlib
+import os
 
+# Dynamically import all tool modules in this directory (except __init__.py and tool_base.py)
+_tool_dir = os.path.dirname(__file__)
+for fname in os.listdir(_tool_dir):
+    if fname.endswith('.py') and fname not in ('__init__.py', 'tool_base.py'):
+        modname = fname[:-3]
+        importlib.import_module(f'janito.agent.tools.{modname}')

janito/agent/tools/ask_user.py

@@ -1,64 +1,61 @@
-from janito.agent.tool_handler import ToolHandler
-from prompt_toolkit import PromptSession
-from prompt_toolkit.key_binding import KeyBindings
-from prompt_toolkit.enums import EditingMode
-from prompt_toolkit.formatted_text import HTML
-from prompt_toolkit.styles import Style
-
-
-@ToolHandler.register_tool
-def ask_user(question: str) -> str:
-    """
-    Ask the user a question and return their response.
-
-    Args:
-        question (str): The question to ask the user.
-    """
-    from rich import print as rich_print
-    from rich.panel import Panel
-
-    rich_print(Panel.fit(question, title="Question", style="cyan"))
-
-    bindings = KeyBindings()
+from janito.agent.tools.tool_base import ToolBase
+from janito.agent.tools.rich_utils import print_info, print_success
+
+class AskUserTool(ToolBase):
+    """Ask the user a question and return their response."""
+    def call(self, question: str) -> str:
+        from rich import print as rich_print
+        from rich.panel import Panel
+        from prompt_toolkit import PromptSession
+        from prompt_toolkit.key_binding import KeyBindings
+        from prompt_toolkit.enums import EditingMode
+        from prompt_toolkit.formatted_text import HTML
+        from prompt_toolkit.styles import Style
+
+        rich_print(Panel.fit(question, title="Question", style="cyan"))
+
+        bindings = KeyBindings()
+        mode = {'multiline': False}
+
+        @bindings.add('c-r')
+        def _(event):
+            pass
+
+        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>')
+            else:
+                return HTML('<b>Single-line mode (Enter to submit). Type /multi for multiline.</b>')
+
+        session = PromptSession(
+            multiline=False,
+            key_bindings=bindings,
+            editing_mode=EditingMode.EMACS,
+            bottom_toolbar=get_toolbar,
+            style=style
+        )
+
+        prompt_icon = HTML('<prompt>💬 </prompt>')
+
+        while True:
+            response = session.prompt(prompt_icon)
+            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
+                session.multiline = False
+                continue
+            else:
+                return response
 
-    mode = {'multiline': False}
 
-    @bindings.add('c-r')
-    def _(event):
-        # Disable reverse search
-        pass
-
-    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>')
-        else:
-            return HTML('<b>Single-line mode (Enter to submit). Type /multi for multiline.</b>')
-
-    session = PromptSession(
-        multiline=False,
-        key_bindings=bindings,
-        editing_mode=EditingMode.EMACS,
-        bottom_toolbar=get_toolbar,
-        style=style
-    )
-
-    prompt_icon = HTML('<prompt>💬 </prompt>')
-
-    while True:
-        response = session.prompt(prompt_icon)
-        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
-            session.multiline = False
-            continue
-        else:
-            return response
+from janito.agent.tool_handler import ToolHandler
+ToolHandler.register_tool(AskUserTool, name="ask_user")

janito/agent/tools/fetch_url.py

@@ -1,40 +1,35 @@
 import requests
-from typing import Optional, Callable
+from typing import Optional
 from bs4 import BeautifulSoup
 from janito.agent.tool_handler import ToolHandler
 from janito.agent.tools.rich_utils import print_info, print_success, print_error
+from janito.agent.tools.tool_base import ToolBase
 
-@ToolHandler.register_tool
-def fetch_url(url: str, search_strings: list[str] = None, on_progress: Optional[Callable[[dict], None]] = None) -> str:
-    """
-    Fetch the content of a web page and extract its text.
+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:
+        print_info(f"🌐 Fetching URL: {url} ... ")
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        self.update_progress(f"Fetched URL with status {response.status_code}")
+        soup = BeautifulSoup(response.text, 'html.parser')
+        text = soup.get_text(separator='\n')
 
-    Args:
-        url (str): The URL to fetch.
-        search_strings (list[str], optional): List of strings to filter the extracted text around those strings.
-        on_progress (callable, optional): Callback function for streaming progress updates.
-    """
-    print_info(f"\U0001F310 Fetching URL: {url} ... ")
-    response = requests.get(url, timeout=10)
-    response.raise_for_status()
-    if on_progress:
-        on_progress({'event': 'fetched', 'status_code': response.status_code})
-    soup = BeautifulSoup(response.text, 'html.parser')
-    text = soup.get_text(separator='\n')
+        if search_strings:
+            filtered = []
+            for s in search_strings:
+                idx = text.find(s)
+                if idx != -1:
+                    start = max(0, idx - 200)
+                    end = min(len(text), idx + len(s) + 200)
+                    snippet = text[start:end]
+                    filtered.append(snippet)
+            if filtered:
+                text = '\n...\n'.join(filtered)
+            else:
+                text = "No matches found for the provided search strings."
 
-    if search_strings:
-        filtered = []
-        for s in search_strings:
-            idx = text.find(s)
-            if idx != -1:
-                start = max(0, idx - 200)
-                end = min(len(text), idx + len(s) + 200)
-                snippet = text[start:end]
-                filtered.append(snippet)
-        if filtered:
-            text = '\n...\n'.join(filtered)
-        else:
-            text = "No matches found for the provided search strings."
+        print_success("\u2705 Success")
+        return text
 
-    print_success("\u2705 Success")
-    return text
+ToolHandler.register_tool(FetchUrlTool, name="fetch_url")

janito/agent/tools/file_ops.py

@@ -1,72 +1,114 @@
 import os
 import shutil
 from janito.agent.tool_handler import ToolHandler
-from janito.agent.tools.rich_utils import print_info, print_success, print_error, format_path
+from janito.agent.tools.rich_utils import print_info, print_success, print_error
+from janito.agent.tools.utils import expand_path, display_path
+from janito.agent.tools.tool_base import ToolBase
 
-@ToolHandler.register_tool
-def create_file(path: str, content: str, overwrite: bool = False) -> str:
+class CreateFileTool(ToolBase):
     """
     Create a new file or update an existing file with the given content.
-
-    Args:
-        path (str): Path to the file to create or update.
-        content (str): Content to write to the file.
-        overwrite (bool): Whether to overwrite the file if it exists.
     """
-    updating = os.path.exists(path) and not os.path.isdir(path)
-    if os.path.exists(path):
-        if os.path.isdir(path):
-            print_error("❌ Error: is a directory")
-            return f"❌ Cannot create file: '{path}' is an existing directory."
-        if not overwrite:
-            print_error(f"❗ Error: file '{path}' exists and overwrite is False")
-            return f"❗ Cannot create file: '{path}' already exists and overwrite is False."
-    if updating and overwrite:
-        print_info(f"📝 Updating file: '{format_path(path)}' ... ")
-    else:
-        print_info(f"📝 Creating file: '{format_path(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:
-        f.write(content)
-    print_success("✅ Success")
-    if old_lines is not None:
+    def call(self, path: str, content: str, overwrite: 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):
+                print_error(f"❌ Error: is a directory")
+                return f"❌ Cannot create file: '{disp_path}' is an existing directory."
+            if not overwrite:
+                print_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:
+            print_info(f"📝 Updating file: '{disp_path}' ... ")
+        else:
+            print_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:
+            f.write(content)
+        print_success("✅ Success")
+        if old_lines is not None:
+            new_lines = content.count('\n') + 1 if content else 0
+            return f"✅ Successfully updated the file at '{disp_path}' ({old_lines} > {new_lines} lines)."
         new_lines = content.count('\n') + 1 if content else 0
-        return f"✅ Successfully updated the file at '{path}' ({old_lines} > {new_lines} lines)."
-    else:
-        return f"✅ Successfully created the file at '{path}'."
+        return f"✅ Successfully created the file at '{disp_path}' ({new_lines} lines)."
 
+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 to the directory to create.
+            overwrite (bool): Whether to remove the directory if it exists.
+        Returns:
+            str: Result message.
+        """
+        original_path = path
+        path = expand_path(path)
+        disp_path = display_path(original_path, path)
+        if os.path.exists(path):
+            if not os.path.isdir(path):
+                print_error(f"❌ Path '{disp_path}' exists and is not a directory.")
+                return f"❌ Path '{disp_path}' exists and is not a directory."
+            if not overwrite:
+                print_error(f"❗ Directory '{disp_path}' already exists and overwrite is False.")
+                return f"❗ Directory '{disp_path}' already exists and overwrite is False."
+            # Remove existing directory if overwrite is True
+            shutil.rmtree(path)
+            print_info(f"🗑️  Removed existing directory: '{disp_path}'")
+        os.makedirs(path, exist_ok=True)
+        print_success(f"✅ Created directory: '{disp_path}'")
+        return f"✅ Successfully created directory at '{disp_path}'."
 
-@ToolHandler.register_tool
-def remove_file(path: str) -> str:
-    print_info(f"🗑️  Removing file: '{format_path(path)}' ... ")
-    os.remove(path)
-    print_success("✅ Success")
-    return f"✅ Successfully deleted the file at '{path}'."
+class RemoveFileTool(ToolBase):
+    """
+    Remove a file at the specified path.
+    """
+    def call(self, path: str) -> str:
+        original_path = path
+        path = expand_path(path)
+        disp_path = display_path(original_path, path)
+        print_info(f"🗑️  Removing file: '{disp_path}' ... ")
+        os.remove(path)
+        print_success("✅ Success")
+        return f"✅ Successfully deleted the file at '{disp_path}'."
 
-@ToolHandler.register_tool
-def move_file(source_path: str, destination_path: str, overwrite: bool = False) -> str:
-    print_info(f"🚚 Moving '{format_path(source_path)}' to '{format_path(destination_path)}' ... ")
-    if not os.path.exists(source_path):
-        print_error("❌ Error: source does not exist")
-        return f"❌ Source path '{source_path}' does not exist."
-    if os.path.exists(destination_path):
-        if not overwrite:
-            print_error("❌ Error: destination exists and overwrite is False")
-            return f"❌ Destination path '{destination_path}' already exists. Use overwrite=True to replace it."
-        if os.path.isdir(destination_path):
-            shutil.rmtree(destination_path)
-        else:
-            os.remove(destination_path)
-    shutil.move(source_path, destination_path)
-    print_success("✅ Success")
-    return f"✅ Successfully moved '{source_path}' to '{destination_path}'."
+class MoveFileTool(ToolBase):
+    """
+    Move or rename a file from source to destination.
+    """
+    def call(self, source_path: str, destination_path: str, overwrite: bool = False) -> str:
+        orig_source = source_path
+        orig_dest = destination_path
+        source_path = expand_path(source_path)
+        destination_path = expand_path(destination_path)
+        disp_source = display_path(orig_source, source_path)
+        disp_dest = display_path(orig_dest, destination_path)
+        print_info(f"🚚 Moving '{disp_source}' to '{disp_dest}' ... ")
+        if not os.path.exists(source_path):
+            print_error(f"❌ Error: source does not exist")
+            return f"❌ Source path '{disp_source}' does not exist."
+        if os.path.exists(destination_path):
+            if not overwrite:
+                print_error(f"❗ Error: destination exists and overwrite is False")
+                return f"❗ Destination path '{disp_dest}' already exists and overwrite is False."
+            if os.path.isdir(destination_path):
+                print_error(f"❌ Error: destination is a directory")
+                return f"❌ Destination path '{disp_dest}' is an existing directory."
+        shutil.move(source_path, destination_path)
+        print_success("✅ Success")
+        return f"✅ Successfully moved '{disp_source}' to '{disp_dest}'."
 
-@ToolHandler.register_tool
-def create_directory(path: str) -> str:
-    print_info(f"📁 Creating directory: '{format_path(path)}' ... ")
-    os.makedirs(path, exist_ok=True)
-    print_success("✅ Success")
-    return f"✅ Directory '{path}' created successfully."
+# register tools
+ToolHandler.register_tool(CreateFileTool, name="create_file")
+ToolHandler.register_tool(CreateDirectoryTool, name="create_directory")
+ToolHandler.register_tool(RemoveFileTool, name="remove_file")
+ToolHandler.register_tool(MoveFileTool, name="move_file")