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

janito/agent/tools/find_files.py

@@ -1,56 +1,60 @@
-from janito.agent.tools.tool_base import ToolBase
+from janito.agent.tool_base import ToolBase
 from janito.agent.tool_registry import register_tool
-
+from janito.agent.tools.tools_utils import pluralize
 
 import fnmatch
 from janito.agent.tools.gitignore_utils import filter_ignored
 
+
 @register_tool(name="find_files")
 class FindFilesTool(ToolBase):
+    """
+    Find files in one or more directories matching a pattern. Respects .gitignore.
 
-    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:
+    Args:
+        directories (list[str]): List of directories to search in.
+        pattern (str): File pattern to match. Uses Unix shell-style wildcards (fnmatch), e.g. '*.py', 'data_??.csv', '[a-z]*.txt'.
+        recursive (bool, optional): Whether to search recursively in subdirectories. Defaults to False.
+        max_depth (int, optional): Maximum directory depth to search (0 = only top-level). If None, unlimited. Defaults to None.
+    Returns:
+        str: Newline-separated list of matching file paths. Example:
             "/path/to/file1.py\n/path/to/file2.py"
             "Warning: Empty file pattern provided. Operation skipped."
-        """
+    """
+
+    def call(
+        self,
+        directories: list[str],
+        pattern: str,
+        recursive: bool = False,
+        max_depth: int = None,
+    ) -> str:
         import os
+
         if not pattern:
-            self.report_warning("⚠️ Warning: Empty file pattern provided. Operation skipped.")
+            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 = []
-        rec = "recursively" if recursive else "non-recursively"
+
+        output = []
         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):
+                # Calculate depth
+                rel_path = os.path.relpath(root, directory)
+                depth = 0 if rel_path == "." else rel_path.count(os.sep) + 1
+                if max_depth is not None and depth > max_depth:
+                    # Prune traversal
+                    dirs[:] = []
+                    continue
+                if not recursive and depth > 0:
+                    # Only top-level if not recursive
+                    break
                 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 len(matches) >= max_results:
-                break
-        
-        warning = ""
-        if len(matches) >= max_results:
-            warning = "\n⚠️ Warning: Maximum result limit reached. Some matches may not be shown."
-            suffix = " (Max Reached)"
-        else:
-            suffix = ""
-        self.report_success(f" ✅ {len(matches)} {pluralize('file', len(matches))}{suffix}")
-        return "\n".join(matches) + warning
-
-
-from janito.agent.tools.tools_utils import pluralize
+                    output.append(os.path.join(root, filename))
+        self.report_success(f" ✅ {len(output)} {pluralize('file', len(output))} found")
+        return "\n".join(output)

janito/agent/tools/get_file_outline.py

@@ -1,39 +1,117 @@
-from janito.agent.tools.tool_base import ToolBase
+from janito.agent.tool_base import ToolBase
 from janito.agent.tool_registry import register_tool
-
-
+import os
+import re
+from typing import List
 
 
 @register_tool(name="get_file_outline")
 class GetFileOutlineTool(ToolBase):
-    """Get an outline of a file's structure."""
-    def call(self, file_path: str) -> str:
-        """
-        Get an outline of a file's structure.
+    """
+    Get an outline of a file's structure.
 
-        Args:
-            file_path (str): Path to the file.
+    Note:
+        The outline extraction for Python files is based on regular expression (regex) pattern matching for class and function definitions.
+        This approach may not capture all edge cases or non-standard code structures. For complex files, further examination or more advanced parsing may be required.
 
-        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>"
-        """
+    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 (python)\n| Type    | Name        | Start | End | Parent   |\n|---------|-------------|-------|-----|----------|\n| class   | MyClass     | 1     | 20  |          |\n| method  | my_method   | 3     | 10  | MyClass  |\n| function| my_func     | 22    | 30  |          |\n..."
+            - "Outline: 100 lines (default)\nFile has 100 lines."
+            - "Error reading file: <error message>"
+    """
+
+    def call(self, file_path: str) -> str:
         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:
+            ext = os.path.splitext(file_path)[1].lower()
+            with open(file_path, "r", encoding="utf-8", errors="replace") as f:
                 lines = f.readlines()
-            outline = [line.strip() for line in lines if line.strip()]
-            num_items = len(outline)
-            
-            self.report_success(f" ✅ {num_items} {pluralize('item', num_items)}")
-            return f"Outline: {num_items} items\n" + '\n'.join(outline)
+            if ext == ".py":
+                outline_items = self._parse_python_outline(lines)
+                outline_type = "python"
+                table = self._format_outline_table(outline_items)
+                self.report_success(f"✅ {len(outline_items)} items ({outline_type})")
+                return f"Outline: {len(outline_items)} items ({outline_type})\n" + table
+            else:
+                outline_type = "default"
+                self.report_success(f"✅ {len(lines)} lines ({outline_type})")
+                return f"Outline: {len(lines)} lines ({outline_type})\nFile has {len(lines)} lines."
         except Exception as e:
-            self.report_error(f" ❌ Error reading file: {e}")
+            self.report_error(f"❌ Error reading file: {e}")
             return f"Error reading file: {e}"
 
+    def _parse_python_outline(self, lines: List[str]):
+        # Regex for class, function, and method definitions
+        class_pat = re.compile(r"^(\s*)class\s+(\w+)")
+        func_pat = re.compile(r"^(\s*)def\s+(\w+)")
+        outline = []
+        stack = []  # (name, type, indent, start, parent)
+        for idx, line in enumerate(lines):
+            class_match = class_pat.match(line)
+            func_match = func_pat.match(line)
+            indent = len(line) - len(line.lstrip())
+            if class_match:
+                name = class_match.group(2)
+                parent = stack[-1][1] if stack and stack[-1][0] == "class" else ""
+                stack.append(("class", name, indent, idx + 1, parent))
+            elif func_match:
+                name = func_match.group(2)
+                parent = (
+                    stack[-1][1]
+                    if stack
+                    and stack[-1][0] in ("class", "function")
+                    and indent > stack[-1][2]
+                    else ""
+                )
+                stack.append(("function", name, indent, idx + 1, parent))
+            # Pop stack if indentation decreases
+            while stack and indent < stack[-1][2]:
+                popped = stack.pop()
+                outline.append(
+                    {
+                        "type": (
+                            popped[0]
+                            if popped[0] != "function" or popped[3] == 1
+                            else ("method" if popped[4] else "function")
+                        ),
+                        "name": popped[1],
+                        # Add end line for popped item
+                        "start": popped[3],
+                        "end": idx,
+                        "parent": popped[4],
+                    }
+                )
+        # Pop any remaining items in the stack at EOF
+        for popped in stack:
+            outline.append(
+                {
+                    "type": (
+                        popped[0]
+                        if popped[0] != "function" or popped[3] == 1
+                        else ("method" if popped[4] else "function")
+                    ),
+                    "name": popped[1],
+                    "start": popped[3],
+                    "end": len(lines),
+                    "parent": popped[4],
+                }
+            )
+        return outline
 
-from janito.agent.tools.tools_utils import pluralize
+    def _format_outline_table(self, outline_items):
+        if not outline_items:
+            return "No classes or functions found."
+        header = "| Type    | Name        | Start | End | Parent   |\n|---------|-------------|-------|-----|----------|"
+        rows = []
+        for item in outline_items:
+            rows.append(
+                f"| {item['type']:<7} | {item['name']:<11} | {item['start']:<5} | {item['end']:<3} | {item['parent']:<8} |"
+            )
+        return header + "\n" + "\n".join(rows)

janito/agent/tools/get_lines.py

@@ -1,28 +1,28 @@
-from janito.agent.tools.tool_base import ToolBase
+from janito.agent.tool_base import ToolBase
 from janito.agent.tool_registry import register_tool
-
+from janito.agent.tools.tools_utils import pluralize
 
 
 @register_tool(name="get_lines")
 class GetLinesTool(ToolBase):
-    """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:
-        """
-        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. If both from_line and to_line are None, the entire file is returned in one call—no need to chunk or split requests when reading the full 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.
+    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"
+    """
 
-        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"
-        """
+    def call(self, file_path: str, from_line: int = None, to_line: int = None) -> str:
         from janito.agent.tools.tools_utils import display_path
+
         disp_path = display_path(file_path)
         if from_line and to_line:
             self.report_info(f"📄 Reading {disp_path} lines {from_line}-{to_line}")
@@ -30,39 +30,47 @@ class GetLinesTool(ToolBase):
             self.report_info(f"📄 Reading {disp_path} (all lines)")
 
         try:
-            with open(file_path, 'r', encoding='utf-8') as f:
+            with open(file_path, "r", encoding="utf-8", errors="replace") as f:
                 lines = f.readlines()
-            selected = lines[(from_line-1 if from_line else 0):(to_line if to_line else None)]
+            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)")
+                    self.report_success(
+                        f" ✅ {selected_len} {pluralize('line', selected_len)} (end at line {total_lines})"
+                    )
                 elif to_line < total_lines:
-                    
-                    self.report_success(f" ✅ {selected_len} {pluralize('line', selected_len)} ({total_lines - to_line} lines to end)")
+                    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)")
+                    self.report_success(
+                        f" ✅ {selected_len} {pluralize('line', selected_len)} (end at line {total_lines})"
+                    )
             else:
-                
-                self.report_success(f" ✅ {selected_len} {pluralize('line', selected_len)} (full file)")
+                self.report_success(
+                    f" ✅ {selected_len} {pluralize('line', selected_len)} (full file)"
+                )
             # Prepare header
             if from_line and to_line:
                 header = f"---\nFile: {disp_path} | Lines: {from_line}-{to_line} (of {total_lines})\n---\n"
+                if to_line >= total_lines:
+                    header = f"---\nFile: {disp_path} | Lines: {from_line}-{to_line} (end at line {total_lines})\n---\n"
             elif from_line:
                 header = f"---\nFile: {disp_path} | Lines: {from_line}-END (of {total_lines})\n---\n"
+                header = f"---\nFile: {disp_path} | Lines: {from_line}-END (end at line {total_lines})\n---\n"
             else:
-                header = f"---\nFile: {disp_path} | All lines (total: {total_lines})\n---\n"
-            return header + ''.join(selected)
+                header = (
+                    f"---\nFile: {disp_path} | All lines (total: {total_lines})\n---\n"
+                )
+            return header + "".join(selected)
         except Exception as 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}"
-
-
-from janito.agent.tools.tools_utils import pluralize

janito/agent/tools/gitignore_utils.py

@@ -5,15 +5,15 @@ from janito.agent.tools.utils import expand_path
 _spec = None
 
 
-def load_gitignore_patterns(gitignore_path='.gitignore'):
+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', [])
+        _spec = pathspec.PathSpec.from_lines("gitwildmatch", [])
         return _spec
-    with open(gitignore_path, 'r', encoding='utf-8') as f:
+    with open(gitignore_path, "r", encoding="utf-8", errors="replace") as f:
         lines = f.readlines()
-    _spec = pathspec.PathSpec.from_lines('gitwildmatch', lines)
+    _spec = pathspec.PathSpec.from_lines("gitwildmatch", lines)
     return _spec
 
 
@@ -23,7 +23,7 @@ def is_ignored(path):
     if _spec is None:
         _spec = load_gitignore_patterns()
     # Normalize path to be relative and use forward slashes
-    rel_path = os.path.relpath(path).replace(os.sep, '/')
+    rel_path = os.path.relpath(path).replace(os.sep, "/")
     return _spec.match_file(rel_path)
 
 
@@ -35,7 +35,10 @@ def filter_ignored(root, dirs, files, spec=None):
         spec = _spec
 
     def not_ignored(p):
-        rel_path = os.path.relpath(os.path.join(root, p)).replace(os.sep, '/')
+        rel_path = os.path.relpath(os.path.join(root, p)).replace(os.sep, "/")
+        # Always ignore .git directory (like git does)
+        if rel_path == ".git" or rel_path.startswith(".git/"):
+            return False
         return not spec.match_file(rel_path)
 
     dirs[:] = [d for d in dirs if not_ignored(d)]

janito/agent/tools/move_file.py

@@ -2,25 +2,30 @@ import os
 import shutil
 from janito.agent.tool_registry import register_tool
 from janito.agent.tools.utils import expand_path, display_path
-from janito.agent.tools.tool_base import ToolBase
+from janito.agent.tool_base import ToolBase
+
 
 @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.
+    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.
+        backup (bool, optional): If True, create a backup (.bak) of the destination before moving if it exists. Recommend using backup=True only in the first call to avoid redundant backups. Defaults to False.
+    Returns:
+        str: Status message indicating the result.
+    """
 
-        Returns:
-            str: Status message indicating the result.
-        """
+    def call(
+        self,
+        src_path: str,
+        dest_path: str,
+        overwrite: bool = False,
+        backup: bool = False,
+    ) -> str:
         original_src = src_path
         original_dest = dest_path
         src = expand_path(src_path)
@@ -36,11 +41,15 @@ class MoveFileTool(ToolBase):
             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.")
+                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."
+            if backup:
+                shutil.copy2(dest, dest + ".bak")
         try:
             shutil.move(src, dest)
             self.report_success(f"\u2705 File moved from '{disp_src}' to '{disp_dest}'")

janito/agent/tools/py_compile_file.py

@@ -0,0 +1,40 @@
+from janito.agent.tool_base import ToolBase
+from janito.agent.tool_registry import register_tool
+
+from typing import Optional
+import py_compile
+
+
+@register_tool(name="py_compile_file")
+class PyCompileFileTool(ToolBase):
+    """
+    Validate a Python file by compiling it with py_compile.
+    Useful to validate python files after changing them, especially after import changes.
+
+    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>"
+    """
+
+    def call(self, file_path: str, doraise: Optional[bool] = True) -> str:
+        self.report_info(f"🛠️  Compiling Python file: {file_path}")
+
+        if not (file_path.endswith(".py") or file_path.endswith(".pyw")):
+            msg = f"Error: {file_path} is not a Python (.py/.pyw) file."
+            self.report_error(f" [py_compile_file] {msg}")
+            return msg
+        try:
+            py_compile.compile(file_path, doraise=doraise)
+            self.report_success(" ✅ Compiled")
+            return "✅ Compiled"
+        except py_compile.PyCompileError as e:
+            self.report_error(f" [py_compile_file] Compile error: {e}")
+            return f"Compile error: {e}"
+        except Exception as e:
+            self.report_error(f" [py_compile_file] Error: {e}")
+            return f"Error: {e}"

janito/agent/tools/remove_directory.py

@@ -1,40 +1,50 @@
-from janito.agent.tools.tool_base import ToolBase
+from janito.agent.tool_base import ToolBase
 from janito.agent.tool_registry import register_tool
+from janito.agent.tools.tools_utils import pluralize
 
 import shutil
 import os
-
+import zipfile
 
 
 @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:
-        """
-        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})")
-
+    """
+    Remove a directory. If recursive=False and directory not empty, raises error.
+
+    Args:
+        directory (str): Path to the directory to remove.
+        recursive (bool, optional): Remove recursively if True. Defaults to False.
+        backup (bool, optional): If True, create a backup (.bak.zip) before removing. Recommend using backup=True only in the first call to avoid redundant backups. Defaults to False.
+    Returns:
+        str: Status message indicating result. Example:
+            - "Directory removed: /path/to/dir"
+            - "Error removing directory: <error message>"
+    """
+
+    def call(
+        self, directory: str, recursive: bool = False, backup: bool = False
+    ) -> str:
+        self.report_info(
+            f"\U0001f5c3\ufe0f  Removing directory: {directory} (recursive={recursive})"
+        )
         try:
+            if backup and os.path.exists(directory) and os.path.isdir(directory):
+                backup_zip = directory.rstrip("/\\") + ".bak.zip"
+                with zipfile.ZipFile(backup_zip, "w", zipfile.ZIP_DEFLATED) as zipf:
+                    for root, dirs, files in os.walk(directory):
+                        for file in files:
+                            abs_path = os.path.join(root, file)
+                            rel_path = os.path.relpath(
+                                abs_path, os.path.dirname(directory)
+                            )
+                            zipf.write(abs_path, rel_path)
             if recursive:
                 shutil.rmtree(directory)
             else:
                 os.rmdir(directory)
-            
-            self.report_success(f"✅ 1 {pluralize('directory', 1)}")
+            self.report_success(f"\u2705 1 {pluralize('directory', 1)}")
             return f"Directory removed: {directory}"
         except Exception as e:
-            self.report_error(f" ❌ Error removing directory: {e}")
+            self.report_error(f" \u274c Error removing directory: {e}")
             return f"Error removing directory: {e}"
-
-
-from janito.agent.tools.tools_utils import pluralize

janito/agent/tools/remove_file.py

@@ -1,38 +1,40 @@
 import os
+import shutil
 from janito.agent.tool_registry import register_tool
 from janito.agent.tools.utils import expand_path, display_path
-from janito.agent.tools.tool_base import ToolBase
+from janito.agent.tool_base import ToolBase
+
 
 @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.
+    Args:
+        file_path (str): Path to the file to remove.
+        backup (bool, optional): If True, create a backup (.bak) before removing. Recommend using backup=True only in the first call to avoid redundant backups. Defaults to False.
+    Returns:
+        str: Status message indicating the result. Example:
+            - "\u2705 Successfully removed the file at ..."
+            - "\u2757 Cannot remove file: ..."
+    """
 
-        Returns:
-            str: Status message indicating the result. Example:
-                - "✅ Successfully removed the file at ..."
-                - "❗ Cannot remove file: ..."
-        """
+    def call(self, file_path: str, backup: bool = False) -> str:
         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."
+            self.report_error(f"\u274c File '{disp_path}' does not exist.")
+            return f"\u274c 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."
+            self.report_error(f"\u274c Path '{disp_path}' is not a file.")
+            return f"\u274c Path '{disp_path}' is not a file."
         try:
+            if backup:
+                shutil.copy2(path, path + ".bak")
             os.remove(path)
-            self.report_success(f"✅ File removed: '{disp_path}'")
-            return f"✅ Successfully removed the file at '{disp_path}'."
+            self.report_success(f"\u2705 File removed: '{disp_path}'")
+            return f"\u2705 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}"
+            self.report_error(f"\u274c Error removing file: {e}")
+            return f"\u274c Error removing file: {e}"