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

janito/agent/tools/append_text_to_file.py

@@ -0,0 +1,41 @@
+from janito.agent.tools.tool_base import ToolBase
+from janito.agent.tool_registry import register_tool
+
+@register_tool(name="append_text_to_file")
+class AppendTextToFileTool(ToolBase):
+    """
+    Append the given text to the end of a file.
+    """
+    def call(self, file_path: str, text_to_append: str) -> str:
+        """
+        Append the given text to the end of a file.
+
+        Append the given text to the end of a file.
+
+        Args:
+            file_path (str): Path to the file where text will be appended.
+            text_to_append (str): The text content to append to the file.
+        Returns:
+            str: Status message. Example formats:
+                - "Appended 3 lines to /path/to/file.txt"
+                - "Warning: No text provided to append. Operation skipped."
+                - "Error appending text: <error message>"
+        """
+        if not text_to_append:
+            self.report_warning("⚠️ Warning: No text provided to append. Operation skipped.")
+            return "Warning: No text provided to append. Operation skipped."
+        disp_path = display_path(file_path)
+        self.report_info(f"📝 Appending to {disp_path} ({len(text_to_append)} chars)")
+        try:
+            with open(file_path, 'a', encoding='utf-8') as f:
+                f.write(text_to_append)
+            
+            num_lines = text_to_append.count('\n') + (1 if text_to_append else 0)
+            self.report_success(f"✅ {num_lines} {pluralize('line', num_lines)} appended")
+            return f"Appended {num_lines} {pluralize('line', num_lines)} to {file_path}"
+        except Exception as e:
+            self.report_error(f"❌ Error: {e}")
+            return f"Error appending text: {e}"
+# Use display_path for consistent path reporting
+from janito.agent.tools.tools_utils import display_path
+from janito.agent.tools.tools_utils import pluralize

janito/agent/tools/ask_user.py

@@ -1,9 +1,23 @@
 from janito.agent.tools.tool_base import ToolBase
-from janito.agent.tools.rich_utils import print_info, print_success
+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.
+
+        Returns:
+            str: The user's response as a string. Example:
+                - "Yes"
+                - "No"
+                - "Some detailed answer..."
+        """
+
         from rich import print as rich_print
         from rich.panel import Panel
         from prompt_toolkit import PromptSession
@@ -57,5 +71,4 @@ class AskUserTool(ToolBase):
                 return response
 
 
-from janito.agent.tool_handler import ToolHandler
-ToolHandler.register_tool(AskUserTool, name="ask_user")
+from janito.agent.tool_registry import register_tool

janito/agent/tools/create_directory.py

@@ -0,0 +1,31 @@
+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
+
+@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.
+
+        Returns:
+            str: Status message indicating the result. Example:
+                - "✅ Successfully created the directory at ..."
+                - "❗ Cannot create directory: ..."
+        """
+        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):
+                self.report_error(f"❌ Path '{disp_path}' exists and is not a directory.")
+                return f"❌ Path '{disp_path}' exists and is not a directory."
+        # Directory creation logic would go here
+        return f"✅ Successfully created the directory at '{disp_path}'."

janito/agent/tools/create_file.py

@@ -0,0 +1,52 @@
+import os
+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.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.
+
+        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.
+
+        Returns:
+            str: Status message indicating the result. Example:
+                - "✅ Successfully created the file at ..."
+                - "❗ Cannot create file: ..."
+        """
+        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:
+            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)."

janito/agent/tools/fetch_url.py

@@ -1,17 +1,33 @@
 import requests
-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.tool_registry import register_tool
+
 from janito.agent.tools.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:
-        print_info(f"🌐 Fetching URL: {url} ... ")
+        """
+        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.
+
+        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."
+        """
+        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(f"Fetched URL with status {response.status_code}")
+        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')
 
@@ -27,9 +43,8 @@ class FetchUrlTool(ToolBase):
             if filtered:
                 text = '\n...\n'.join(filtered)
             else:
-                text = "No matches found for the provided search strings."
+                text = "No lines found for the provided search strings."
 
-        print_success("\u2705 Success")
+        self.report_success("✅ Result")
         return text
 
-ToolHandler.register_tool(FetchUrlTool, name="fetch_url")

janito/agent/tools/find_files.py

@@ -1,31 +1,50 @@
 from janito.agent.tools.tool_base import ToolBase
-from janito.agent.tool_handler import ToolHandler
-from janito.agent.tools.rich_utils import print_info, print_success
-import os
+from janito.agent.tool_registry import register_tool
+
+
 import fnmatch
+from janito.agent.tools.gitignore_utils import filter_ignored
 
+@register_tool(name="find_files")
 class FindFilesTool(ToolBase):
-    """Find files in a directory matching a pattern."""
-    def call(self, directory: str, pattern: str, recursive: bool=False, max_results: int=100) -> str:
+
+    def call(self, directories: list[str], pattern: str, recursive: bool=False, max_results: int=100) -> str:
+        """
+        Find files in one or more directories matching a pattern. Respects .gitignore.
+
+        Args:
+            directories: List of directories to search in.
+            pattern: File pattern to match. Uses Unix shell-style wildcards (fnmatch), e.g. '*.py', 'data_??.csv', '[a-z]*.txt'.
+            recursive: Whether to search recursively in subdirectories. Defaults to False.
+            max_results: Maximum number of results to return. Defaults to 100.
+        Returns:
+            Newline-separated list of matching file paths. Example:
+            "/path/to/file1.py\n/path/to/file2.py"
+            "Warning: Empty file pattern provided. Operation skipped."
+        """
         import os
-        def _display_path(path):
-            import os
-            if os.path.isabs(path):
-                return path
-            return os.path.relpath(path)
-        disp_path = _display_path(directory)
-        rec = "recursively" if recursive else "non-recursively"
-        print_info(f"\U0001F50D Searching '{disp_path}' for pattern '{pattern}' ({rec}, max {max_results})")
-        self.update_progress(f"Searching for files in {directory} matching {pattern}")
+        if not pattern:
+            self.report_warning("⚠️ Warning: Empty file pattern provided. Operation skipped.")
+            return "Warning: Empty file pattern provided. Operation skipped."
+        from janito.agent.tools.tools_utils import display_path
         matches = []
-        for root, dirs, files in os.walk(directory):
-            for filename in fnmatch.filter(files, pattern):
-                matches.append(os.path.join(root, filename))
-                if len(matches) >= max_results:
+        rec = "recursively" if recursive else "non-recursively"
+        for directory in directories:
+            disp_path = display_path(directory)
+            self.report_info(f"🔍 Searching for files '{pattern}' in '{disp_path}'")
+            for root, dirs, files in os.walk(directory):
+                dirs, files = filter_ignored(root, dirs, files)
+                for filename in fnmatch.filter(files, pattern):
+                    matches.append(os.path.join(root, filename))
+                    if len(matches) >= max_results:
+                        break
+                if not recursive:
                     break
-            if not recursive:
+            if len(matches) >= max_results:
                 break
-        print_success(f"✅ {len(matches)} found")
+        
+        self.report_success(f" ✅ {len(matches)} {pluralize('file', len(matches))}")
         return "\n".join(matches)
 
-ToolHandler.register_tool(FindFilesTool, name="find_files")
+
+from janito.agent.tools.tools_utils import pluralize

janito/agent/tools/get_file_outline.py

@@ -1,21 +1,39 @@
 from janito.agent.tools.tool_base import ToolBase
-from janito.agent.tool_handler import ToolHandler
+from janito.agent.tool_registry import register_tool
 
-from janito.agent.tools.rich_utils import print_info, print_success, print_error
 
+
+
+@register_tool(name="get_file_outline")
 class GetFileOutlineTool(ToolBase):
     """Get an outline of a file's structure."""
     def call(self, file_path: str) -> str:
-        print_info(f"📄 Getting outline for: {file_path}")
-        self.update_progress(f"Getting outline for: {file_path}")
+        """
+        Get an outline of a file's structure.
+
+        Args:
+            file_path (str): Path to the file.
+
+        Returns:
+            str: Outline of the file's structure, starting with a summary line. Example:
+                - "Outline: 5 items\nclass MyClass:\ndef my_function():\n..."
+                - "Error reading file: <error message>"
+        """
+        from janito.agent.tools.tools_utils import display_path
+        disp_path = display_path(file_path)
+        self.report_info(f"📄 Getting outline for: {disp_path}")
+
         try:
             with open(file_path, 'r', encoding='utf-8') as f:
                 lines = f.readlines()
             outline = [line.strip() for line in lines if line.strip()]
-            print_success(f"\u2705 Outline generated for {file_path}")
-            return '\n'.join(outline)
+            num_items = len(outline)
+            
+            self.report_success(f" ✅ {num_items} {pluralize('item', num_items)}")
+            return f"Outline: {num_items} items\n" + '\n'.join(outline)
         except Exception as e:
-            print_error(f"\u274c Error reading file: {e}")
+            self.report_error(f" ❌ Error reading file: {e}")
             return f"Error reading file: {e}"
 
-ToolHandler.register_tool(GetFileOutlineTool, name="get_file_outline")
+
+from janito.agent.tools.tools_utils import pluralize

janito/agent/tools/get_lines.py

@@ -1,34 +1,68 @@
 from janito.agent.tools.tool_base import ToolBase
-from janito.agent.tool_handler import ToolHandler
-from janito.agent.tools.rich_utils import print_info, print_success, print_error
+from janito.agent.tool_registry import register_tool
 
+
+
+@register_tool(name="get_lines")
 class GetLinesTool(ToolBase):
-    """Get specific lines from a file."""
+    """Read lines from a file. Returns specific lines if a range is provided, or the entire file if no range is given."""
     def call(self, file_path: str, from_line: int=None, to_line: int=None) -> str:
-        import os
-        def _display_path(path):
-            import os
-            if os.path.isabs(path):
-                return path
-            return os.path.relpath(path)
-        disp_path = _display_path(file_path)
+        """
+        Get specific lines from a file.
+
+        Args:
+            file_path (str): Path to the file to read lines from.
+            from_line (int, optional): Starting line number (1-based). If None, starts from the first line.
+            to_line (int, optional): Ending line number (1-based). If None, reads to the end of the file. If both are None, the entire file is returned.
+
+        Returns:
+            str: File content with a header indicating the file name and line range. Example:
+                - "---\nFile: /path/to/file.py | Lines: 1-10 (of 100)\n---\n<lines...>"
+                - "---\nFile: /path/to/file.py | All lines (total: 100)\n---\n<all lines...>"
+                - "Error reading file: <error message>"
+                - "❗ not found"
+        """
+        from janito.agent.tools.tools_utils import display_path
+        disp_path = display_path(file_path)
         if from_line and to_line:
-            count = to_line - from_line + 1
-            print_info(f"📄 Reading {disp_path}:{from_line} ({count} lines)", end="")
+            self.report_info(f"📄 Reading {disp_path} lines {from_line}-{to_line}")
         else:
-            print_info(f"📄 Reading {disp_path} (all lines)", end="")
-        self.update_progress(f"Getting lines {from_line} to {to_line} from {file_path}")
+            self.report_info(f"📄 Reading {disp_path} (all lines)")
+
         try:
             with open(file_path, 'r', encoding='utf-8') as f:
                 lines = f.readlines()
             selected = lines[(from_line-1 if from_line else 0):(to_line if to_line else None)]
+            selected_len = len(selected)
+            total_lines = len(lines)
+            if from_line and to_line:
+                requested = to_line - from_line + 1
+                if selected_len < requested:
+                    
+                    self.report_success(f" ✅ {selected_len} {pluralize('line', selected_len)} (end)")
+                elif to_line < total_lines:
+                    
+                    self.report_success(f" ✅ {selected_len} {pluralize('line', selected_len)} ({total_lines - to_line} lines to end)")
+                else:
+                    
+                    self.report_success(f" ✅ {selected_len} {pluralize('line', selected_len)} (end)")
+            else:
+                
+                self.report_success(f" ✅ {selected_len} {pluralize('line', selected_len)} (full file)")
+            # Prepare header
             if from_line and to_line:
-                print_success(f" ✅ {to_line - from_line + 1} lines read")
+                header = f"---\nFile: {disp_path} | Lines: {from_line}-{to_line} (of {total_lines})\n---\n"
+            elif from_line:
+                header = f"---\nFile: {disp_path} | Lines: {from_line}-END (of {total_lines})\n---\n"
             else:
-                print_success(f" ✅ {len(lines)} lines read")
-            return ''.join(selected)
+                header = f"---\nFile: {disp_path} | All lines (total: {total_lines})\n---\n"
+            return header + ''.join(selected)
         except Exception as e:
-            print_error(f" ❌ Error: {e}")
+            if isinstance(e, FileNotFoundError):
+                self.report_error("❗ not found")
+                return "❗ not found"
+            self.report_error(f" ❌ Error: {e}")
             return f"Error reading file: {e}"
 
-ToolHandler.register_tool(GetLinesTool, name="get_lines")
+
+from janito.agent.tools.tools_utils import pluralize

janito/agent/tools/move_file.py

@@ -0,0 +1,50 @@
+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
+
+@register_tool(name="move_file")
+class MoveFileTool(ToolBase):
+    """
+    Move a file from src_path to dest_path.
+    """
+    def call(self, src_path: str, dest_path: str, overwrite: bool = False) -> str:
+        """
+        Move a file from src_path to dest_path.
+
+        Args:
+            src_path (str): Source file path.
+            dest_path (str): Destination file path.
+            overwrite (bool, optional): Whether to overwrite if the destination exists. Defaults to False.
+
+        Returns:
+            str: Status message indicating the result.
+        """
+        original_src = src_path
+        original_dest = dest_path
+        src = expand_path(src_path)
+        dest = expand_path(dest_path)
+        disp_src = display_path(original_src, src)
+        disp_dest = display_path(original_dest, dest)
+
+        if not os.path.exists(src):
+            self.report_error(f"\u274c Source file '{disp_src}' does not exist.")
+            return f"\u274c Source file '{disp_src}' does not exist."
+        if not os.path.isfile(src):
+            self.report_error(f"\u274c Source path '{disp_src}' is not a file.")
+            return f"\u274c Source path '{disp_src}' is not a file."
+        if os.path.exists(dest):
+            if not overwrite:
+                self.report_error(f"\u2757 Destination '{disp_dest}' exists and overwrite is False.")
+                return f"\u2757 Destination '{disp_dest}' already exists and overwrite is False."
+            if os.path.isdir(dest):
+                self.report_error(f"\u274c Destination '{disp_dest}' is a directory.")
+                return f"\u274c Destination '{disp_dest}' is a directory."
+        try:
+            shutil.move(src, dest)
+            self.report_success(f"\u2705 File moved from '{disp_src}' to '{disp_dest}'")
+            return f"\u2705 Successfully moved the file from '{disp_src}' to '{disp_dest}'."
+        except Exception as e:
+            self.report_error(f"\u274c Error moving file: {e}")
+            return f"\u274c Error moving file: {e}"

janito/agent/tools/py_compile.py

@@ -1,23 +1,39 @@
 from janito.agent.tools.tool_base import ToolBase
-from janito.agent.tool_handler import ToolHandler
-from janito.agent.tools.rich_utils import print_info, print_success, print_error
+from janito.agent.tool_registry import register_tool
+
+
 from typing import Optional
 import py_compile
 
+@register_tool(name="py_compile")
 class PyCompileTool(ToolBase):
-    """Validate a Python file by compiling it with py_compile."""
+    """
+    Validate a Python file by compiling it with py_compile.
+    Useful to validate python files after changing them, specially after import changes.
+    """
     def call(self, file_path: str, doraise: Optional[bool] = True) -> str:
-        print_info(f"[py_compile] Compiling Python file: {file_path}")
-        self.update_progress(f"Compiling Python file: {file_path}")
+        """
+        Compile a Python file to check for syntax errors.
+
+        Args:
+            file_path (str): Path to the Python file to compile.
+            doraise (bool, optional): Whether to raise exceptions on compilation errors. Defaults to True.
+
+        Returns:
+            str: Compilation status message. Example:
+                - "✅ Compiled"
+                - "Compile error: <error message>"
+                - "Error: <error message>"
+        """
+        self.report_info(f"🛠️  Compiling Python file: {file_path}")
+
         try:
             py_compile.compile(file_path, doraise=doraise)
-            print_success(f"[py_compile] Compiled successfully: {file_path}")
-            return f"Compiled successfully: {file_path}"
+            self.report_success("✅ Compiled")
+            return "✅ Compiled"
         except py_compile.PyCompileError as e:
-            print_error(f"[py_compile] Compile error: {e}")
+            self.report_error(f" [py_compile] Compile error: {e}")
             return f"Compile error: {e}"
         except Exception as e:
-            print_error(f"[py_compile] Error: {e}")
+            self.report_error(f" [py_compile] Error: {e}")
             return f"Error: {e}"
-
-ToolHandler.register_tool(PyCompileTool, name="py_compile_file")

janito/agent/tools/python_exec.py

@@ -1,14 +1,12 @@
-from janito.agent.tool_handler import ToolHandler
-from janito.agent.tools.rich_utils import print_info
-import sys
+
+
 import multiprocessing
 import io
-from typing import Optional
 from janito.agent.tools.tool_base import ToolBase
+from janito.agent.tool_registry import register_tool
 
 
 def _run_python_code(code: str, result_queue):
-    import traceback
     import contextlib
     stdout = io.StringIO()
     stderr = io.StringIO()
@@ -22,18 +20,49 @@ def _run_python_code(code: str, result_queue):
 
 
 # Converted python_exec function into PythonExecTool subclass
+@register_tool(name="python_exec")
 class PythonExecTool(ToolBase):
     """
     Execute Python code in a separate process and capture output.
+    Useful for exact calculations, retrieving the current date and time, or performing any Python-supported operation.
     Args:
         code (str): The Python code to execute.
     Returns:
         str: Formatted stdout, stderr, and return code.
     """
     def call(self, code: str) -> str:
-        print_info(f"🐍 Executing Python code ...")
-        print_info(code)
-        self.update_progress("Starting Python code execution...")
+        """
+        Execute arbitrary Python code, including exact calculations, getting the current date, time, and more.
+
+        Args:
+            code (str): The Python code to execute.
+
+        Returns:
+            str: Formatted output including stdout, stderr, and return code. Example:
+                - "stdout:\n<output>\nstderr:\n<errors>\nreturncode: 0"
+                - "stdout:\n\nstderr:\nNo result returned from process.\nreturncode: -1"
+        """
+        """
+        Execute arbitrary Python code, including exact calculations, getting the current date, time, and more.
+
+        Args:
+            code (str): The Python code to execute.
+
+        Returns:
+            str: Formatted stdout, stderr, and return code.
+        """
+        """
+        Execute arbitrary Python code, including exact calculations, getting the current date, time, and more.
+
+        Args:
+            code (str): The Python code to execute.
+
+        Returns:
+            str: Formatted stdout, stderr, and return code.
+        """
+        self.report_info("🐍 Executing Python code ...")
+        self.report_info(code)
+
         result_queue = multiprocessing.Queue()
         process = multiprocessing.Process(target=_run_python_code, args=(code, result_queue))
         process.start()
@@ -42,13 +71,13 @@ class PythonExecTool(ToolBase):
             result = result_queue.get()
         else:
             result = {'stdout': '', 'stderr': 'No result returned from process.', 'returncode': -1}
-        self.update_progress(f"Python code execution completed with return code: {result['returncode']}")
+
         if result['returncode'] == 0:
-            from janito.agent.tools.rich_utils import print_success
-            print_success(f"\u2705 Python code executed successfully.")
+
+            self.report_success("✅ Python code executed")
         else:
-            from janito.agent.tools.rich_utils import print_error
-            print_error(f"\u274c Python code execution failed with return code {result['returncode']}")
+
+            self.report_error(f"\u274c Python code execution failed with return code {result['returncode']}")
         return f"stdout:\n{result['stdout']}\nstderr:\n{result['stderr']}\nreturncode: {result['returncode']}"
 
-ToolHandler.register_tool(PythonExecTool, name="python_exec")
+