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

janito/agent/tools/find_files.py

@@ -1,58 +1,31 @@
+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
 import fnmatch
-from janito.agent.tool_handler import ToolHandler
-from janito.agent.tools.rich_utils import print_info, print_success, print_error
 
-@ToolHandler.register_tool
-def find_files(
-    directory: str,
-    pattern: str,
-    recursive: bool = False,
-    max_results: int = 100
-) -> str:
-    """
-    Find files in a directory matching a pattern.
-    Args:
-        directory (str): The directory to search in.
-        pattern (str): The filename pattern to match (e.g., '*.txt').
-        recursive (bool): Whether to search subdirectories.
-        max_results (int): Maximum number of results to return.
-    Returns:
-        str: Newline-separated list of matching file paths, with summary and warnings if truncated.
-    """
-    print_info(f"🔍 find_files | Dir: {directory} | Pattern: {pattern} | Recursive: {recursive} | Max: {max_results}")
-    # Input validation
-    if not os.path.isdir(directory):
-        print_error(f"❌ Not a directory: {directory}")
-        return ""
-    if not isinstance(max_results, int) or max_results <= 0:
-        print_error(f"❌ Invalid max_results value: {max_results}")
-        return ""
-    matches = []
-    try:
-        if recursive:
-            for root, dirs, files in os.walk(directory):
-                for name in files:
-                    if fnmatch.fnmatch(name, pattern):
-                        matches.append(os.path.join(root, name))
-                        if len(matches) >= max_results:
-                            break
+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:
+        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}")
+        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:
                     break
-        else:
-            for name in os.listdir(directory):
-                full_path = os.path.join(directory, name)
-                if os.path.isfile(full_path) and fnmatch.fnmatch(name, pattern):
-                    matches.append(full_path)
-                    if len(matches) >= max_results:
-                        break
-    except Exception as e:
-        print_error(f"❌ Error during file search: {e}")
-        return ""
-    print_success(f"✅ Found {len(matches)} file(s)")
-    result = f"Total files found: {len(matches)}\n"
-    result += "\n".join(matches)
-    if len(matches) == max_results:
-        result += "\n# WARNING: Results truncated at max_results. There may be more matching files."
-    return result
+            if not recursive:
+                break
+        print_success(f"✅ {len(matches)} found")
+        return "\n".join(matches)
 
+ToolHandler.register_tool(FindFilesTool, name="find_files")

janito/agent/tools/get_file_outline.py

@@ -0,0 +1,21 @@
+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
+
+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}")
+        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)
+        except Exception as e:
+            print_error(f"\u274c Error reading file: {e}")
+            return f"Error reading file: {e}"
+
+ToolHandler.register_tool(GetFileOutlineTool, name="get_file_outline")

janito/agent/tools/get_lines.py

@@ -1,58 +1,34 @@
-import os
+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, format_path, format_number
+from janito.agent.tools.rich_utils import print_info, print_success, print_error
 
-@ToolHandler.register_tool
-def get_lines(
-    file_path: str,
-    from_line: int = None,
-    to_line: int = None
-) -> str:
-    """
-    Get lines from a file, optionally with a summary of lines outside the viewed range.
-    Always returns the total number of lines in the file at the top of the output.
-    
-    Parameters:
-      - file_path (string): Path to the file.
-      - from_line (integer, optional): First line to view (1-indexed). If omitted with to_line, returns all lines.
-      - to_line (integer, optional): Last line to view (inclusive, 1-indexed, and cannot be more than 200 lines from from_line).
-    
-    If both from_line and to_line are omitted, returns all lines in the file.
-    It is recommended to request at least 100 lines or the full file for more efficient context building.
-    """
-    if from_line is None and to_line is None:
-        print_info(f"📂 get_lines | Path: {format_path(file_path)} | All lines requested")
-    else:
-        print_info(f"📂 get_lines | Path: {format_path(file_path)} | Lines ({from_line}-{to_line})")
-    if not os.path.isfile(file_path):
-        print_info(f"ℹ️ File not found: {file_path}")
-        return ""
-    with open(file_path, "r", encoding="utf-8") as f:
-        lines = f.readlines()
-    total_lines = len(lines)
-    if from_line is None and to_line is None:
-        numbered_content = ''.join(f"{i+1}: {line}" for i, line in enumerate(lines))
-        print_success(f"✅ Returned all {total_lines} lines")
-        return f"Total lines in file: {total_lines}\n" + numbered_content
-    # Validate range
-    if from_line is None or to_line is None:
-        print_error(f"❌ Both from_line and to_line must be provided, or neither.")
-        return ""
-    if from_line < 1 or to_line < from_line or (to_line - from_line > 200):
-        print_error(f"❌ Invalid line range: {from_line}-{to_line} for file with {total_lines} lines.")
-        return ""
-    if to_line > total_lines:
-        to_line = total_lines
-    selected = lines[from_line-1:to_line]
-    numbered_content = ''.join(f"{i}: {line}" for i, line in zip(range(from_line, to_line+1), selected))
-    before = lines[:from_line-1]
-    after = lines[to_line:]
-    before_summary = f"... {len(before)} lines before ...\n" if before else ""
-    after_summary = f"... {len(after)} lines after ...\n" if after else ""
-    summary = before_summary + after_summary
-    if from_line == 1 and to_line == total_lines:
-        print_success(f"✅ Returned all {total_lines} lines")
-    else:
-        print_success(f"✅ Returned lines {from_line} to {to_line} of {total_lines}")
-    total_line_info = f"Total lines in file: {total_lines}\n"
-    return total_line_info + summary + numbered_content
+class GetLinesTool(ToolBase):
+    """Get specific lines from a file."""
+    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)
+        if from_line and to_line:
+            count = to_line - from_line + 1
+            print_info(f"📄 Reading {disp_path}:{from_line} ({count} lines)", end="")
+        else:
+            print_info(f"📄 Reading {disp_path} (all lines)", end="")
+        self.update_progress(f"Getting lines {from_line} to {to_line} from {file_path}")
+        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)]
+            if from_line and to_line:
+                print_success(f" ✅ {to_line - from_line + 1} lines read")
+            else:
+                print_success(f" ✅ {len(lines)} lines read")
+            return ''.join(selected)
+        except Exception as e:
+            print_error(f" ❌ Error: {e}")
+            return f"Error reading file: {e}"
+
+ToolHandler.register_tool(GetLinesTool, name="get_lines")

janito/agent/tools/gitignore_utils.py

@@ -1,15 +1,17 @@
 import os
 import pathspec
+from janito.agent.tools.utils import expand_path
 
 _spec = None
 
 
 def load_gitignore_patterns(gitignore_path='.gitignore'):
     global _spec
+    gitignore_path = expand_path(gitignore_path)
     if not os.path.exists(gitignore_path):
         _spec = pathspec.PathSpec.from_lines('gitwildmatch', [])
         return _spec
-    with open(gitignore_path, 'r') as f:
+    with open(gitignore_path, 'r', encoding='utf-8') as f:
         lines = f.readlines()
     _spec = pathspec.PathSpec.from_lines('gitwildmatch', lines)
     return _spec
@@ -17,6 +19,7 @@ def load_gitignore_patterns(gitignore_path='.gitignore'):
 
 def is_ignored(path):
     global _spec
+    path = expand_path(path)
     if _spec is None:
         _spec = load_gitignore_patterns()
     # Normalize path to be relative and use forward slashes

janito/agent/tools/py_compile.py

@@ -1,26 +1,23 @@
+from janito.agent.tools.tool_base import ToolBase
 from janito.agent.tool_handler import ToolHandler
-from janito.agent.tools.rich_utils import print_info
-import py_compile
+from janito.agent.tools.rich_utils import print_info, print_success, print_error
 from typing import Optional
+import py_compile
 
-@ToolHandler.register_tool
-def py_compile_file(path: str, doraise: Optional[bool] = True) -> str:
-    """
-    Validate a Python file by compiling it with py_compile.
-    This tool should be used to validate Python files after changes.
-
-    Args:
-        path (str): Path to the Python file to validate.
-        doraise (Optional[bool]): If True, raise exceptions on compilation errors. Default is True.
+class PyCompileTool(ToolBase):
+    """Validate a Python file by compiling it with py_compile."""
+    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}")
+        try:
+            py_compile.compile(file_path, doraise=doraise)
+            print_success(f"[py_compile] Compiled successfully: {file_path}")
+            return f"Compiled successfully: {file_path}"
+        except py_compile.PyCompileError as e:
+            print_error(f"[py_compile] Compile error: {e}")
+            return f"Compile error: {e}"
+        except Exception as e:
+            print_error(f"[py_compile] Error: {e}")
+            return f"Error: {e}"
 
-    Returns:
-        str: Success message or error details if compilation fails.
-    """
-    print_info(f"[py_compile_file] Validating Python file: {path}")
-    try:
-        py_compile.compile(path, doraise=doraise)
-        return f"Validation successful: {path} is a valid Python file."
-    except FileNotFoundError:
-        return f"Validation failed: File not found: {path}"
-    except py_compile.PyCompileError as e:
-        return f"Validation failed: {e}"
+ToolHandler.register_tool(PyCompileTool, name="py_compile_file")

janito/agent/tools/python_exec.py

@@ -3,7 +3,8 @@ from janito.agent.tools.rich_utils import print_info
 import sys
 import multiprocessing
 import io
-from typing import Callable, Optional
+from typing import Optional
+from janito.agent.tools.tool_base import ToolBase
 
 
 def _run_python_code(code: str, result_queue):
@@ -20,28 +21,34 @@ def _run_python_code(code: str, result_queue):
     })
 
 
-@ToolHandler.register_tool
-def python_exec(code: str, on_progress: Optional[Callable[[dict], None]] = None) -> str:
+# Converted python_exec function into PythonExecTool subclass
+class PythonExecTool(ToolBase):
     """
     Execute Python code in a separate process and capture output.
-
     Args:
         code (str): The Python code to execute.
-        on_progress (Optional[Callable[[dict], None]]): Optional callback function for streaming progress updates (not used).
-
     Returns:
-        str: A formatted message string containing stdout, stderr, and return code.
+        str: Formatted stdout, stderr, and return code.
     """
-    print_info(f"[python_exec] Executing Python code:")
-    print_info(code)
-    result_queue = multiprocessing.Queue()
-    process = multiprocessing.Process(target=_run_python_code, args=(code, result_queue))
-    process.start()
-    process.join()
-    if not result_queue.empty():
-        result = result_queue.get()
-    else:
-        result = {'stdout': '', 'stderr': 'No result returned from process.', 'returncode': -1}
-    print_info(f"[python_exec] Execution completed.")
-    print_info(f"[python_exec] Return code: {result['returncode']}")
-    return f"stdout:\n{result['stdout']}\nstderr:\n{result['stderr']}\nreturncode: {result['returncode']}"
+    def call(self, code: str) -> str:
+        print_info(f"🐍 Executing Python code ...")
+        print_info(code)
+        self.update_progress("Starting Python code execution...")
+        result_queue = multiprocessing.Queue()
+        process = multiprocessing.Process(target=_run_python_code, args=(code, result_queue))
+        process.start()
+        process.join()
+        if not result_queue.empty():
+            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.")
+        else:
+            from janito.agent.tools.rich_utils import print_error
+            print_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")

janito/agent/tools/remove_directory.py

@@ -1,38 +1,24 @@
-import os
-import shutil
+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, format_path
+import shutil
+import os
 
-def _is_dir_empty(path):
-    return not any(os.scandir(path))
+from janito.agent.tools.rich_utils import print_info, print_success, print_error
 
-@ToolHandler.register_tool
-def remove_directory(path: str, recursive: bool = False) -> str:
-    """
-    Remove a directory. If recursive is False and the directory is not empty, return an error.
+class RemoveDirectoryTool(ToolBase):
+    """Remove a directory. If recursive=False and directory not empty, raises error."""
+    def call(self, directory: str, recursive: bool = False) -> str:
+        print_info(f"🗃️ Removing directory: {directory} (recursive={recursive})")
+        self.update_progress(f"Removing directory: {directory} (recursive={recursive})")
+        try:
+            if recursive:
+                shutil.rmtree(directory)
+            else:
+                os.rmdir(directory)
+            print_success(f"\u2705 Directory removed: {directory}")
+            return f"Directory removed: {directory}"
+        except Exception as e:
+            print_error(f"\u274c Error removing directory: {e}")
+            return f"Error removing directory: {e}"
 
-    Args:
-        path (str): Path to the directory to remove.
-        recursive (bool): Whether to remove non-empty directories recursively. Default is False.
-    Returns:
-        str: Result message.
-    """
-    if not os.path.exists(path):
-        print_error(f"❌ Directory '{path}' does not exist.")
-        return f"❌ Directory '{path}' does not exist."
-    if not os.path.isdir(path):
-        print_error(f"❌ Path '{path}' is not a directory.")
-        return f"❌ Path '{path}' is not a directory."
-    if recursive:
-        print_info(f"🗑️  Recursively removing directory: '{format_path(path)}' ... ")
-        shutil.rmtree(path)
-        print_success("✅ Success")
-        return f"✅ Successfully removed directory and all contents at '{path}'."
-    else:
-        if not _is_dir_empty(path):
-            print_error(f"❌ Directory '{path}' is not empty. Use recursive=True to remove non-empty directories.")
-            return f"❌ Directory '{path}' is not empty. Use recursive=True to remove non-empty directories."
-        print_info(f"🗑️  Removing empty directory: '{format_path(path)}' ... ")
-        os.rmdir(path)
-        print_success("✅ Success")
-        return f"✅ Successfully removed empty directory at '{path}'."
+ToolHandler.register_tool(RemoveDirectoryTool, name="remove_directory")

janito/agent/tools/replace_text_in_file.py

@@ -1,67 +1,67 @@
-import os
+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, format_path
 
-@ToolHandler.register_tool
-def replace_text_in_file(file_path: str, search_text: str, replacement_text: str, replace_all: bool = False) -> str:
-    """
+class ReplaceTextInFileTool(ToolBase):
+    """Replace exact occurrences of a given text in a file.
 
-    Replace exact occurrences of a given text in a file. The match must be exact, including whitespace and indentation, to avoid breaking file syntax or formatting.
+NOTE: Indentation (leading whitespace) must be included in both search_text and replacement_text. This tool does not automatically adjust or infer indentation; matches are exact, including whitespace.
+"""
+    def call(self, file_path: str, search_text: str, replacement_text: str, replace_all: bool = False) -> str:
+        """
+        Replace exact occurrences of a given text in a file.
 
-    Args:
-        file_path (str): Path to the plain text file.
-        search_text (str): Text to search for (exact match).
-        replacement_text (str): Text to replace search_text with.
-        replace_all (bool): Whether to replace all occurrences or just the first. Default is False.
-    Returns:
-        str: Result message.
-    """
-    search_preview = (search_text[:15] + '...') if len(search_text) > 15 else search_text
-    replace_preview = (replacement_text[:15] + '...') if len(replacement_text) > 15 else replacement_text
-    replace_all_msg = f" | Replace all: True" if replace_all else ""
-    print_info(f"📝 replace_text_in_file | Path: {format_path(file_path)} | Search: '{search_preview}' | Replacement: '{replace_preview}'{replace_all_msg}")
-    if not os.path.isfile(file_path):
-        print_error(f"❌ File not found: {file_path}")
-        return f"❌ Error: File not found: {file_path}"
-    try:
-        with open(file_path, "r", encoding="utf-8") as f:
-            content = f.read()
-    except PermissionError:
-        print_error(f"❌ Permission denied: {file_path}")
-        return f"❌ Error: Permission denied: {file_path}"
-    except Exception as e:
-        print_error(f"❌ Error reading file: {e}")
-        return f"❌ Error reading file: {e}"
+        Args:
+            file_path (str): Path to the file.
+            search_text (str): Text to search for. Must include indentation (leading whitespace) if present in the file.
+            replacement_text (str): Replacement text. Must include desired indentation (leading whitespace).
+            replace_all (bool): If True, replace all occurrences; otherwise, only the first occurrence.
+        Returns:
+            str: Status message.
+        """
+        import os
+        filename = os.path.basename(file_path)
+        action = "all occurrences" if replace_all else "first occurrence"
+        # Show only concise info (lengths, not full content)
+        search_preview = (search_text[:20] + '...') if len(search_text) > 20 else search_text
+        replace_preview = (replacement_text[:20] + '...') if len(replacement_text) > 20 else replacement_text
+        print_info(f"\U0001F4DD Replacing in {filename}: '{search_preview}'  '{replace_preview}' ({action})", end="")
+        self.update_progress(f"Replacing text in {file_path}")
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
 
-    count = content.count(search_text)
-    if count == 0:
-        print_info(f"ℹ️  Search text not found in file.")
-        return f"ℹ️ No occurrences of search text found in '{file_path}'."
-    if replace_all:
-        new_content = content.replace(search_text, replacement_text)
-        replaced_count = count
-    else:
-        if count > 1:
-            # Find line numbers where search_text appears
-            lines = content.splitlines()
-            found_lines = [i+1 for i, line in enumerate(lines) if search_text in line]
-            preview = search_text[:40] + ('...' if len(search_text) > 40 else '')
-            print_error(f"❌ Search text found multiple times ({count}). Please provide a more exact match or set replace_all=True.")
-            return (
-                f"❌ Error: Search text found {count} times in '{file_path}'. "
-                f"Preview: '{preview}'. Found at lines: {found_lines}. "
-                f"Please provide a more exact match."
-            )
-        new_content = content.replace(search_text, replacement_text, 1)
-        replaced_count = 1 if count == 1 else 0
-    try:
-        with open(file_path, "w", encoding="utf-8") as f:
-            f.write(new_content)
-    except PermissionError:
-        print_error(f"❌ Permission denied when writing: {file_path}")
-        return f"❌ Error: Permission denied when writing: {file_path}"
-    except Exception as e:
-        print_error(f"❌ Error writing file: {e}")
-        return f"❌ Error writing file: {e}"
-    print_success(f"✅ Replaced {replaced_count} occurrence(s) of search text in '{file_path}'.")
-    return f"✅ Replaced {replaced_count} occurrence(s) of search text in '{file_path}'."
+            if replace_all:
+                replaced_count = content.count(search_text)
+                new_content = content.replace(search_text, replacement_text)
+            else:
+                occurrences = content.count(search_text)
+                if occurrences > 1:
+                    print_error(f" ❌ Error: Search text is not unique ({occurrences} occurrences found). Provide more detailed context.")
+                    return f"Error: Search text is not unique ({occurrences} occurrences found) in {file_path}. Provide more detailed context for unique replacement."
+                replaced_count = 1 if occurrences == 1 else 0
+                new_content = content.replace(search_text, replacement_text, 1)
+            with open(file_path, 'w', encoding='utf-8') as f:
+                f.write(new_content)
+            warning = ''
+            if replaced_count == 0:
+                warning = f" [Warning: Search text not found in file]"
+                print_error(warning)
+            print_success(f" ✅ {replaced_count} replaced{warning}")
+            # Indentation check for agent warning
+            def leading_ws(line):
+                import re
+                m = re.match(r"^\s*", line)
+                return m.group(0) if m else ''
+            search_indent = leading_ws(search_text.splitlines()[0]) if search_text.splitlines() else ''
+            replace_indent = leading_ws(replacement_text.splitlines()[0]) if replacement_text.splitlines() else ''
+            indent_warning = ''
+            if search_indent != replace_indent:
+                indent_warning = f" [Warning: Indentation mismatch between search and replacement text: '{search_indent}' vs '{replace_indent}']"
+            return f"Text replaced in {file_path}{warning}{indent_warning}"
+
+        except Exception as e:
+            print_error(f" ❌ Error: {e}")
+            return f"Error replacing text: {e}"
+
+ToolHandler.register_tool(ReplaceTextInFileTool, name="replace_text_in_file")

janito/agent/tools/rich_utils.py

@@ -3,14 +3,14 @@ from rich.text import Text
 
 console = Console()
 
-def print_info(message: str):
-    console.print(message, style="cyan")
+def print_info(message: str, end="\n"):
+    console.print(message, style="cyan", end=end)
 
-def print_success(message: str):
-    console.print(message, style="bold green")
+def print_success(message: str, end="\n"):
+    console.print(message, style="bold green", end=end)
 
-def print_error(message: str):
-    console.print(message, style="bold red")
+def print_error(message: str, end="\n"):
+    console.print(message, style="bold red", end=end)
 
 def print_warning(message: str):
     console.print(message, style="yellow")