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

janito/agent/tools/remove_directory.py

@@ -1,24 +1,40 @@
 from janito.agent.tools.tool_base import ToolBase
-from janito.agent.tool_handler import ToolHandler
+from janito.agent.tool_registry import register_tool
+
 import shutil
 import os
 
-from janito.agent.tools.rich_utils import print_info, print_success, print_error
 
+
+@register_tool(name="remove_directory")
 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})")
+        """
+        Remove a directory.
+
+        Args:
+            directory (str): Path to the directory to remove.
+            recursive (bool, optional): Remove recursively if True. Defaults to False.
+
+        Returns:
+            str: Status message indicating result. Example:
+                - "Directory removed: /path/to/dir"
+                - "Error removing directory: <error message>"
+        """
+        self.report_info(f"🗃️  Removing directory: {directory} (recursive={recursive})")
+
         try:
             if recursive:
                 shutil.rmtree(directory)
             else:
                 os.rmdir(directory)
-            print_success(f"\u2705 Directory removed: {directory}")
+            
+            self.report_success(f"✅ 1 {pluralize('directory', 1)}")
             return f"Directory removed: {directory}"
         except Exception as e:
-            print_error(f"\u274c Error removing directory: {e}")
+            self.report_error(f" ❌ Error removing directory: {e}")
             return f"Error removing directory: {e}"
 
-ToolHandler.register_tool(RemoveDirectoryTool, name="remove_directory")
+
+from janito.agent.tools.tools_utils import pluralize

janito/agent/tools/remove_file.py

@@ -0,0 +1,38 @@
+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
+
+@register_tool(name="remove_file")
+class RemoveFileTool(ToolBase):
+    """
+    Remove a file at the specified path.
+    """
+    def call(self, file_path: str) -> str:
+        """
+        Remove a file from the filesystem.
+
+        Args:
+            file_path (str): Path to the file to remove.
+
+        Returns:
+            str: Status message indicating the result. Example:
+                - "✅ Successfully removed the file at ..."
+                - "❗ Cannot remove file: ..."
+        """
+        original_path = file_path
+        path = expand_path(file_path)
+        disp_path = display_path(original_path, path)
+        if not os.path.exists(path):
+            self.report_error(f"❌ File '{disp_path}' does not exist.")
+            return f"❌ File '{disp_path}' does not exist."
+        if not os.path.isfile(path):
+            self.report_error(f"❌ Path '{disp_path}' is not a file.")
+            return f"❌ Path '{disp_path}' is not a file."
+        try:
+            os.remove(path)
+            self.report_success(f"✅ File removed: '{disp_path}'")
+            return f"✅ Successfully removed the file at '{disp_path}'."
+        except Exception as e:
+            self.report_error(f"❌ Error removing file: {e}")
+            return f"❌ Error removing file: {e}"

janito/agent/tools/replace_text_in_file.py

@@ -1,10 +1,14 @@
 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
+from janito.agent.tool_registry import register_tool
+
+@register_tool(name="replace_text_in_file")
+
 
 class ReplaceTextInFileTool(ToolBase):
     """Replace exact occurrences of a given text in a file.
 
+This tool is designed to make minimal, targeted changes—preferably a small region modifications—rather than rewriting large sections or the entire file. Use it for precise, context-aware edits.
+
 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:
@@ -17,16 +21,24 @@ NOTE: Indentation (leading whitespace) must be included in both search_text and
             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.
+            str: Status message. Example:
+                - "Text replaced in /path/to/file"
+                - "No changes made. [Warning: Search text not found in file] Please review the original file."
+                - "Error replacing text: <error message>"
         """
-        import os
-        filename = os.path.basename(file_path)
-        action = "all occurrences" if replace_all else "first occurrence"
+        from janito.agent.tools.tools_utils import display_path
+        disp_path = display_path(file_path)
+        action = "all occurrences" if replace_all else None
         # 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}")
+        search_lines = len(search_text.splitlines())
+        replace_lines = len(replacement_text.splitlines())
+        info_msg = f"📝 Replacing in {disp_path}: {search_lines}→{replace_lines} lines"
+        if action:
+            info_msg += f" ({action})"
+        self.report_info(info_msg)
+
         try:
             with open(file_path, 'r', encoding='utf-8') as f:
                 content = f.read()
@@ -37,17 +49,26 @@ NOTE: Indentation (leading whitespace) must be included in both search_text and
             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."
+                    self.report_warning("⚠️ Search text is not unique.")
+                    warning_detail = "The search text is not unique. Expand your search context with surrounding lines to ensure uniqueness."
+                    return f"No changes made. {warning_detail}"
                 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)
+            if new_content != content:
+                with open(file_path, 'w', encoding='utf-8') as f:
+                    f.write(new_content)
+                file_changed = True
+            else:
+                file_changed = False
             warning = ''
             if replaced_count == 0:
-                warning = f" [Warning: Search text not found in file]"
-                print_error(warning)
-            print_success(f" ✅ {replaced_count} replaced{warning}")
+                warning = " [Warning: Search text not found in file]"
+            if not file_changed:
+                self.report_warning(" ℹ No changes made.")
+                concise_warning = "The search text was not found. Expand your search context with surrounding lines if needed."
+                return f"No changes made. {concise_warning}"
+            
+            self.report_success(f" ✅ {replaced_count} {pluralize('block', replaced_count)} replaced")
             # Indentation check for agent warning
             def leading_ws(line):
                 import re
@@ -58,10 +79,12 @@ NOTE: Indentation (leading whitespace) must be included in both search_text and
             indent_warning = ''
             if search_indent != replace_indent:
                 indent_warning = f" [Warning: Indentation mismatch between search and replacement text: '{search_indent}' vs '{replace_indent}']"
+            if 'warning_detail' in locals():
+                return f"Text replaced in {file_path}{warning}{indent_warning}\n{warning_detail}"
             return f"Text replaced in {file_path}{warning}{indent_warning}"
 
         except Exception as e:
-            print_error(f" ❌ Error: {e}")
+            self.report_error(" ❌ Error")
             return f"Error replacing text: {e}"
 
-ToolHandler.register_tool(ReplaceTextInFileTool, name="replace_text_in_file")
+from janito.agent.tools.tools_utils import pluralize

janito/agent/tools/run_bash_command.py

@@ -1,80 +1,107 @@
-from janito.agent.tools.tool_base import ToolBase
-from janito.agent.tool_handler import ToolHandler
-import subprocess
-
-from janito.agent.tools.rich_utils import print_info, print_success, print_error
-
-import tempfile
-import os
-import sys
-
-class RunBashCommandTool(ToolBase):
-    """
-    Execute a non-interactive bash command and capture live output.
-
-    Args:
-        command (str): The bash command to execute.
-        timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
-        require_confirmation (bool, optional): If True, require user confirmation before running. Defaults to False.
-        interactive (bool, optional): If True, warns that the command may require user interaction. Defaults to False. Non-interactive commands are preferred for automation and reliability.
-
-    Returns:
-        str: File paths and line counts for stdout and stderr.
-    """
-    def call(self, command: str, timeout: int = 60, require_confirmation: bool = False, interactive: bool = False) -> str:
-        print_info(f"🖥️  Running bash command: {command}")
-        if interactive:
-            print_info("⚠️  Warning: This command might be interactive, require user input, and might hang.")
-            print()
-            sys.stdout.flush()
-        self.update_progress(f"Running bash command: {command}")
-        try:
-            with tempfile.NamedTemporaryFile(mode='w+', prefix='run_bash_stdout_', delete=False, encoding='utf-8') as stdout_file, \
-                 tempfile.NamedTemporaryFile(mode='w+', prefix='run_bash_stderr_', delete=False, encoding='utf-8') as stderr_file:
-                process = subprocess.Popen(
-                    command, shell=True,
-                    stdout=stdout_file,
-                    stderr=stderr_file,
-                    text=True
-                )
-                try:
-                    return_code = process.wait(timeout=timeout)
-                except subprocess.TimeoutExpired:
-                    process.kill()
-                    print_error(f" ❌ Timed out after {timeout} seconds.")
-                    return f"Command timed out after {timeout} seconds."
-
-                # Print live output to user
-                stdout_file.flush()
-                stderr_file.flush()
-                with open(stdout_file.name, 'r', encoding='utf-8') as out_f:
-                    out_f.seek(0)
-                    for line in out_f:
-                        print(line, end='')
-                with open(stderr_file.name, 'r', encoding='utf-8') as err_f:
-                    err_f.seek(0)
-                    for line in err_f:
-                        print(line, end='', file=sys.stderr)
-
-                # Count lines
-                with open(stdout_file.name, 'r', encoding='utf-8') as out_f:
-                    stdout_lines = sum(1 for _ in out_f)
-                with open(stderr_file.name, 'r', encoding='utf-8') as err_f:
-                    stderr_lines = sum(1 for _ in err_f)
-
-                print_success(f" ✅ return code {return_code}")
-                warning_msg = ""
-                if interactive:
-                    warning_msg = "⚠️  Warning: This command might be interactive, require user input, and might hang.\n"
-                return (
-                    warning_msg +
-                    f"stdout_file: {stdout_file.name} (lines: {stdout_lines})\n"
-                    f"stderr_file: {stderr_file.name} (lines: {stderr_lines})\n"
-                    f"returncode: {return_code}\n"
-                    f"Use the get_lines tool to inspect the contents of these files when needed."
-                )
-        except Exception as e:
-            print_error(f" ❌ Error: {e}")
-            return f"Error running command: {e}"
-
-ToolHandler.register_tool(RunBashCommandTool, name="run_bash_command")
+from janito.agent.tools.tool_base import ToolBase
+from janito.agent.tool_registry import register_tool
+
+import subprocess
+import tempfile
+import sys
+
+@register_tool(name="run_bash_command")
+class RunBashCommandTool(ToolBase):
+    """
+    Execute a non-interactive command using the bash shell and capture live output.
+
+    This tool explicitly invokes the 'bash' shell (not just the system default shell), so it requires bash to be installed and available in the system PATH. On Windows, this will only work if bash is available (e.g., via WSL, Git Bash, or similar).
+
+    Args:
+        command (str): The bash command to execute.
+        timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
+        require_confirmation (bool, optional): If True, require user confirmation before running. Defaults to False.
+        interactive (bool, optional): If True, warns that the command may require user interaction. Defaults to False. Non-interactive commands are preferred for automation and reliability.
+
+    Returns:
+        str: File paths and line counts for stdout and stderr.
+    """
+    def call(self, command: str, timeout: int = 60, require_confirmation: bool = False, interactive: bool = False) -> str:
+        """
+        Execute a bash command and capture live output.
+
+        Args:
+            command (str): The bash command to execute.
+            timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
+            require_confirmation (bool, optional): If True, require user confirmation before running. Defaults to False.
+            interactive (bool, optional): If True, warns that the command may require user interaction. Defaults to False.
+
+        Returns:
+            str: Output and status message.
+        """
+        """
+        Execute a bash command and capture live output.
+
+        Args:
+            command (str): The bash command to execute.
+            timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
+            require_confirmation (bool, optional): If True, require user confirmation before running. Defaults to False.
+            interactive (bool, optional): If True, warns that the command may require user interaction. Defaults to False.
+
+        Returns:
+            str: Output and status message.
+        """
+        if not command.strip():
+            self.report_warning("⚠️ Warning: Empty command provided. Operation skipped.")
+            return "Warning: Empty command provided. Operation skipped."
+        self.report_info(f"🖥️  Running bash command: {command}\n")
+        if interactive:
+            self.report_info("⚠️  Warning: This command might be interactive, require user input, and might hang.")
+
+            sys.stdout.flush()
+
+        try:
+            with tempfile.NamedTemporaryFile(mode='w+', prefix='run_bash_stdout_', delete=False, encoding='utf-8') as stdout_file, \
+                 tempfile.NamedTemporaryFile(mode='w+', prefix='run_bash_stderr_', delete=False, encoding='utf-8') as stderr_file:
+                # Use bash explicitly for command execution
+                process = subprocess.Popen(
+                    ["bash", "-c", command],
+                    stdout=stdout_file,
+                    stderr=stderr_file,
+                    text=True
+                )
+                try:
+                    return_code = process.wait(timeout=timeout)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    self.report_error(f" ❌ Timed out after {timeout} seconds.")
+                    return f"Command timed out after {timeout} seconds."
+
+                # Print live output to user
+                stdout_file.flush()
+                stderr_file.flush()
+                with open(stdout_file.name, 'r', encoding='utf-8') as out_f:
+                    out_f.seek(0)
+                    for line in out_f:
+                        self.report_stdout(line)
+                with open(stderr_file.name, 'r', encoding='utf-8') as err_f:
+                    err_f.seek(0)
+                    for line in err_f:
+                        self.report_stderr(line)
+
+                # Count lines
+                with open(stdout_file.name, 'r', encoding='utf-8') as out_f:
+                    stdout_lines = sum(1 for _ in out_f)
+                with open(stderr_file.name, 'r', encoding='utf-8') as err_f:
+                    stderr_lines = sum(1 for _ in err_f)
+
+                self.report_success(f" ✅ return code {return_code}")
+                warning_msg = ""
+                if interactive:
+                    warning_msg = "⚠️  Warning: This command might be interactive, require user input, and might hang.\n"
+                return (
+                    warning_msg +
+                    f"stdout_file: {stdout_file.name} (lines: {stdout_lines})\n"
+                    f"stderr_file: {stderr_file.name} (lines: {stderr_lines})\n"
+                    f"returncode: {return_code}\n"
+                    f"Use the get_lines tool to inspect the contents of these files when needed."
+                )
+        except Exception as e:
+            self.report_error(f" ❌ Error: {e}")
+            return f"Error running command: {e}"
+

janito/agent/tools/search_files.py

@@ -1,26 +1,45 @@
 from janito.agent.tools.tool_base import ToolBase
-from janito.agent.tool_handler import ToolHandler
-import os
+from janito.agent.tool_registry import register_tool
 
-from janito.agent.tools.rich_utils import print_info, print_success
+import os
+from janito.agent.tools.gitignore_utils import filter_ignored
 
+@register_tool(name="search_files")
 class SearchFilesTool(ToolBase):
-    """Search for a text pattern in all files within a directory and return matching lines."""
-    def call(self, directory: str, pattern: str) -> str:
-        print_info(f"🔎 Searching for pattern '{pattern}' in directory {directory}")
-        self.update_progress(f"Searching for pattern '{pattern}' in directory {directory}")
+    """Search for a text pattern in all files within a directory and return matching lines. Respects .gitignore."""
+    def call(self, directories: list[str], pattern: str) -> str:
+        """
+        Search for a text pattern in all files within one or more directories and return matching lines.
+
+        Args:
+            directories (list[str]): List of directories to search in.
+            pattern (str): Plain text substring to search for in files. (Not a regular expression or glob pattern.)
+
+        Returns:
+            str: Matching lines from files as a newline-separated string, each formatted as 'filepath:lineno: line'. Example:
+                - "/path/to/file.py:10: def my_function():"
+                - "Warning: Empty search pattern provided. Operation skipped."
+        """
+        if not pattern:
+            self.report_warning("⚠️ Warning: Empty search pattern provided. Operation skipped.")
+            return "Warning: Empty search pattern provided. Operation skipped."
         matches = []
-        for root, dirs, files in os.walk(directory):
-            for filename in files:
-                path = os.path.join(root, filename)
-                try:
-                    with open(path, 'r', encoding='utf-8', errors='ignore') as f:
-                        for lineno, line in enumerate(f, 1):
-                            if pattern in line:
-                                matches.append(f"{path}:{lineno}: {line.strip()}")
-                except Exception:
-                    continue
-        print_success(f"\u2705 {len(matches)} matches found")
+        for directory in directories:
+            self.report_info(f"🔎 Searching for text '{pattern}' in '{directory}'")
+            for root, dirs, files in os.walk(directory):
+                dirs, files = filter_ignored(root, dirs, files)
+                for filename in files:
+                    path = os.path.join(root, filename)
+                    try:
+                        with open(path, 'r', encoding='utf-8', errors='ignore') as f:
+                            for lineno, line in enumerate(f, 1):
+                                if pattern in line:
+                                    matches.append(f"{path}:{lineno}: {line.strip()}")
+                    except Exception:
+                        continue
+        
+        self.report_success(f" ✅ {len(matches)} {pluralize('line', len(matches))}")
         return '\n'.join(matches)
 
-ToolHandler.register_tool(SearchFilesTool, name="search_files")
+
+from janito.agent.tools.tools_utils import pluralize

janito/agent/tools/tool_base.py

@@ -8,17 +8,44 @@ class ToolBase(ABC):
         self.progress_messages = []
         self._progress_callback = None  # Will be set by ToolHandler if available
 
+    def report_stdout(self, message: str):
+        self.update_progress({"type": "stdout", "message": message})
+
+    def report_stderr(self, message: str):
+        self.update_progress({"type": "stderr", "message": message})
+
     @abstractmethod
     def call(self, **kwargs):
+        """
+        Abstract call method for tool execution. Should be overridden by subclasses.
+
+        Args:
+            **kwargs: Arbitrary keyword arguments for the tool.
+
+        Returns:
+            Any: The result of the tool execution.
+        """
         """
         Trigger the tool's action. Must be implemented by subclasses.
         """
         pass
 
-    def update_progress(self, message: str):
+    def update_progress(self, progress: dict):
         """
         Report progress. Subclasses can override this to customize progress reporting.
         """
-        self.progress_messages.append(message)
+        self.progress_messages.append(progress)
         if hasattr(self, '_progress_callback') and self._progress_callback:
-            self._progress_callback({'event': 'progress', 'message': message})
+            self._progress_callback(progress)
+
+    def report_info(self, message: str):
+        self.update_progress({"type": "info", "tool": self.__class__.__name__, "message": message})
+
+    def report_success(self, message: str):
+        self.update_progress({"type": "success", "tool": self.__class__.__name__, "message": message})
+
+    def report_error(self, message: str):
+        self.update_progress({"type": "error", "tool": self.__class__.__name__, "message": message})
+
+    def report_warning(self, message: str):
+        self.update_progress({"type": "warning", "tool": self.__class__.__name__, "message": message})

janito/agent/tools/tools_utils.py

@@ -0,0 +1,11 @@
+def display_path(path):
+    import os
+    if os.path.isabs(path):
+        return path
+    return os.path.relpath(path)
+
+def pluralize(word: str, count: int) -> str:
+    """Return the pluralized form of word if count != 1, unless word already ends with 's'."""
+    if count == 1 or word.endswith('s'):
+        return word
+    return word + 's'

janito/agent/tools/utils.py

@@ -1,5 +1,4 @@
 import os
-import sys
 
 
 def expand_path(path: str) -> str:

janito/cli/_print_config.py

@@ -1,5 +1,5 @@
 import os
-from janito.agent.tools.rich_utils import print_info, print_success, print_error, print_warning, print_magenta
+from janito.rich_utils import print_info, print_warning, print_magenta
 from ._utils import home_shorten
 
 def print_config_items(items, color_label=None):

janito/cli/arg_parser.py

@@ -12,7 +12,7 @@ def create_parser():
 
     # Mutually exclusive group for system prompt options
     group = parser.add_mutually_exclusive_group()
-    group.add_argument("-s", "--system-prompt", type=str, default=None, help="Optional system prompt as a raw string.")
+    group.add_argument("-s", "--system", type=str, default=None, help="Optional system prompt as a raw string.")
     group.add_argument("--system-file", type=str, default=None, help="Path to a plain text file to use as the system prompt (no template rendering, takes precedence over --system-prompt)")
 
     parser.add_argument("-r", "--role", type=str, default=None, help="Role description for the default system prompt")
@@ -35,4 +35,5 @@ def create_parser():
     parser.add_argument("--config-reset-local", action="store_true", help="Remove the local config file (~/.janito/config.json)")
     parser.add_argument("--config-reset-global", action="store_true", help="Remove the global config file (~/.janito/config.json)")
     parser.add_argument("--trust", action="store_true", help="Enable trust mode: suppresses run_bash_command output, only shows output file locations.")
+    parser.add_argument("-V", "--vanilla", action="store_true", default=False, help="Vanilla mode: disables tools, system prompt, and temperature (unless -t is set)")
     return parser

janito/cli/config_commands.py

@@ -1,6 +1,7 @@
 import sys
-from janito.agent.config import local_config, global_config
+from janito.agent.config import local_config, global_config, CONFIG_OPTIONS
 from janito.agent.runtime_config import unified_config, runtime_config
+from janito.agent.config_defaults import CONFIG_DEFAULTS
 from rich import print
 from ._utils import home_shorten
 
@@ -22,7 +23,6 @@ def handle_config_commands(args):
                 sys.exit(1)
             runtime_config.set(key, val.strip())
     if args.set_local_config:
-        from janito.agent.config import CONFIG_OPTIONS
         try:
             key, val = args.set_local_config.split("=", 1)
         except ValueError:
@@ -39,7 +39,6 @@ def handle_config_commands(args):
         did_something = True
 
     if args.set_global_config:
-        from janito.agent.config import CONFIG_OPTIONS
         try:
             key, val = args.set_global_config.split("=", 1)
         except ValueError:
@@ -83,15 +82,13 @@ def handle_config_commands(args):
         global_items = {}
 
         # Collect and group keys
-        from janito.agent.config_defaults import CONFIG_DEFAULTS
         local_keys = set(local_config.all().keys())
         global_keys = set(global_config.all().keys())
         all_keys = set(CONFIG_DEFAULTS.keys()) | global_keys | local_keys
         if not (local_keys or global_keys):
             print("No configuration found.")
         else:
-            from janito.agent.config import get_api_key
-            from janito.agent.runtime_config import unified_config
+            # Imports previously inside block to avoid circular import at module level
             # Handle template as nested dict
             for key in sorted(local_keys):
                 if key == "template":

janito/cli/main.py

@@ -20,7 +20,7 @@ def main():
     parser = create_parser()
     args = parser.parse_args()
 
-    from janito.agent.config import CONFIG_OPTIONS
+    from janito.agent.config import CONFIG_OPTIONS  # Kept here: avoids circular import at module level
     from janito.agent.config_defaults import CONFIG_DEFAULTS
     import sys
     if getattr(args, "help_config", False):
@@ -33,7 +33,7 @@ def main():
     handle_config_commands(args)
     setup_verbose_logging(args)
     if getattr(args, 'web', False):
-        import subprocess
+        import subprocess  # Only needed if launching web
         subprocess.run(['python', '-m', 'janito.web'])
     else:
         run_cli(args)