janito 3.6.1__py3-none-any.whl → 3.8.0__py3-none-any.whl

janito/tools/adapters/local/create_file.py

@@ -0,0 +1,138 @@
+import os
+from janito.tools.path_utils import expand_path
+from janito.tools.adapters.local.adapter import register_local_tool
+
+from janito.tools.tool_utils import display_path
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.i18n import tr
+from janito.tools.loop_protection_decorator import protect_against_loops
+
+from janito.tools.adapters.local.validate_file_syntax.core import validate_file_syntax
+
+
+@register_local_tool
+class CreateFileTool(ToolBase):
+    """
+    Create a new file with specified content at the given path.
+
+    This tool provides comprehensive file creation capabilities with built-in safety features,
+    automatic syntax validation, and detailed feedback. It handles path expansion, directory
+    creation, encoding issues, and provides clear status messages for both success and failure cases.
+
+    Key Features:
+    - Automatic directory creation for nested paths
+    - UTF-8 encoding with error handling for special characters
+    - Built-in syntax validation for common file types (Python, JavaScript, JSON, YAML, etc.)
+    - Loop protection to prevent excessive file creation
+    - Detailed error messages with context
+    - Safe overwrite protection with preview of existing content
+    - Cross-platform path handling (Windows, macOS, Linux)
+
+    Args:
+        path (str): Target file path. Supports relative and absolute paths, with automatic
+                   expansion of user home directory (~) and environment variables.
+                   Examples: "src/main.py", "~/Documents/config.json", "$HOME/.env"
+        content (str): File content to write. Empty string creates empty file.
+                      Supports any text content including Unicode characters, newlines,
+                      and binary-safe text representation.
+        overwrite (bool, optional): If True, allows overwriting existing files. Default: False.
+                                   When False, prevents accidental overwrites by checking
+                                   file existence and showing current content. Always review
+                                   existing content before enabling overwrite.
+
+    Returns:
+        str: Detailed status message including:
+            - Success confirmation with line count
+            - File path (display-friendly format)
+            - Syntax validation results
+            - Existing content preview (when overwrite blocked)
+            - Error details (when creation fails)
+
+    Raises:
+        No direct exceptions - all errors are caught and returned as user-friendly messages.
+        Common error cases include: permission denied, invalid path format, disk full,
+        or file exists (when overwrite=False).
+
+    Security Features:
+        - Loop protection: Maximum 5 calls per 10 seconds for the same file path
+        - Path traversal prevention: Validates and sanitizes file paths
+        - Permission checking: Respects file system permissions
+        - Atomic writes: Prevents partial file creation on errors
+
+    Examples:
+        Basic file creation:
+        >>> create_file("hello.py", "print('Hello, World!')")
+        ✅ Created file 1 lines.
+        ✅ Syntax OK
+
+        Creating nested directories:
+        >>> create_file("src/utils/helpers.py", "def helper(): pass")
+        ✅ Created file 2 lines.
+        ✅ Syntax OK
+
+        Overwrite protection:
+        >>> create_file("existing.txt", "new content")
+        ❗ Cannot create file: file already exists at 'existing.txt'.
+        --- Current file content ---
+        old content
+
+    Note: After successful creation, automatic syntax validation is performed based on
+    file extension. Results are appended to the return message for immediate feedback.
+    """
+
+    permissions = ToolPermissions(write=True)
+    tool_name = "create_file"
+
+    @protect_against_loops(max_calls=5, time_window=10.0, key_field="path")
+    def run(self, path: str, content: str, overwrite: bool = False) -> str:
+        path = expand_path(path)
+        disp_path = display_path(path)
+        if os.path.exists(path) and not overwrite:
+            try:
+                with open(path, "r", encoding="utf-8", errors="replace") as f:
+                    existing_content = f.read()
+            except Exception as e:
+                existing_content = f"[Error reading file: {e}]"
+            return tr(
+                "❗ Cannot create file: file already exists at '{disp_path}'.\n--- Current file content ---\n{existing_content}",
+                disp_path=disp_path,
+                existing_content=existing_content,
+            )
+        # Determine if we are overwriting an existing file
+        is_overwrite = os.path.exists(path) and overwrite
+        if is_overwrite:
+            # Overwrite branch: log only overwrite warning (no create message)
+            self.report_action(
+                tr("⚠️  Overwriting file '{disp_path}'", disp_path=disp_path),
+                ReportAction.CREATE,
+            )
+        dir_name = os.path.dirname(path)
+        if dir_name:
+            os.makedirs(dir_name, exist_ok=True)
+        if not is_overwrite:
+            # Create branch: log file creation message
+            self.report_action(
+                tr("📝 Create file '{disp_path}' ...", disp_path=disp_path),
+                ReportAction.CREATE,
+            )
+        with open(path, "w", encoding="utf-8", errors="replace") as f:
+            f.write(content)
+        new_lines = content.count("\n") + 1 if content else 0
+        self.report_success(
+            tr("✅ {new_lines} lines", new_lines=new_lines), ReportAction.CREATE
+        )
+        # Perform syntax validation and append result
+        validation_result = validate_file_syntax(path)
+        if is_overwrite:
+            # Overwrite branch: return minimal overwrite info to user
+            return (
+                tr("✅ {new_lines} lines", new_lines=new_lines)
+                + f"\n{validation_result}"
+            )
+        else:
+            # Create branch: return detailed create success to user
+            return (
+                tr("✅ Created file {new_lines} lines.", new_lines=new_lines)
+                + f"\n{validation_result}"
+            )

janito/{plugins/tools/core → tools/adapters/local}/fetch_url.py

@@ -5,7 +5,7 @@ import json
 from pathlib import Path
 from bs4 import BeautifulSoup
 from typing import Dict, Any, Optional
-from .decorators import register_core_tool
+from janito.tools.adapters.local.adapter import register_local_tool
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
 from janito.i18n import tr
@@ -13,8 +13,8 @@ from janito.tools.tool_utils import pluralize
 from janito.tools.loop_protection_decorator import protect_against_loops
 
 
-@register_core_tool
-class FetchUrl(ToolBase):
+@register_local_tool
+class FetchUrlTool(ToolBase):
     """
     Fetch the content of a web page and extract its text.
 
@@ -190,23 +190,11 @@ class FetchUrl(ToolBase):
 
         Also implements URL whitelist checking and browser-like behavior.
         """
-        # Check URL whitelist and blocked sites
+        # Check URL whitelist
         from janito.tools.url_whitelist import get_url_whitelist_manager
-        from janito.tools.blocked_sites import get_blocked_sites_manager
 
         whitelist_manager = get_url_whitelist_manager()
-        blocked_manager = get_blocked_sites_manager()
 
-        # Check blocked sites first
-        if blocked_manager.is_url_blocked(url):
-            error_message = tr("Blocked: Site is in blocked list")
-            self.report_error(
-                tr("❗ Blocked: Site is in blocked list"),
-                ReportAction.READ,
-            )
-            return error_message
-
-        # Then check whitelist
         if not whitelist_manager.is_url_allowed(url):
             error_message = tr("Blocked")
             self.report_error(
@@ -257,7 +245,7 @@ class FetchUrl(ToolBase):
             self.session_cache[url] = content
             return content
         except requests.exceptions.HTTPError as http_err:
-            status_code = http_err.response.status_code if http_err.response is not None else None
+            status_code = http_err.response.status_code if http_err.response else None
 
             # Map status codes to descriptions
             status_descriptions = {
@@ -303,7 +291,14 @@ class FetchUrl(ToolBase):
                 return error_message
             else:
                 status_code_str = str(status_code) if status_code else "Error"
-                description = status_descriptions.get(status_code, "Error")
+                description = status_descriptions.get(
+                    status_code,
+                    (
+                        "Server Error"
+                        if status_code and status_code >= 500
+                        else "Client Error"
+                    ),
+                )
                 self.report_error(
                     f"❗ HTTP {status_code_str} {description}",
                     ReportAction.READ,
@@ -406,7 +401,11 @@ class FetchUrl(ToolBase):
                 cookies=cookies,
                 follow_redirects=follow_redirects,
             )
-            if html_content.startswith("HTTP") or "Error" in html_content or html_content == "Blocked":
+            if (
+                html_content.startswith("HTTP Error ")
+                or html_content == "Error"
+                or html_content == "Blocked"
+            ):
                 return html_content
 
             try:
@@ -435,7 +434,11 @@ class FetchUrl(ToolBase):
             cookies=cookies,
             follow_redirects=follow_redirects,
         )
-        if html_content.startswith("HTTP") or "Error" in html_content or html_content == "Blocked":
+        if (
+            html_content.startswith("HTTP Error ")
+            or html_content == "Error"
+            or html_content == "Blocked"
+        ):
             return html_content
 
         # Extract and clean text

janito/tools/adapters/local/move_file.py

@@ -0,0 +1,131 @@
+import os
+from janito.tools.path_utils import expand_path
+import shutil
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.tools.tool_utils import display_path
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.i18n import tr
+
+
+@register_local_tool
+class MoveFileTool(ToolBase):
+    """
+    Move a file or directory from src_path to dest_path.
+
+    Args:
+        src_path (str): Source file or directory path.
+        dest_path (str): Destination file or directory path.
+        overwrite (bool, optional): Whether to overwrite if the destination exists. Defaults to False.
+        backup (bool, optional): Deprecated. No backups are created anymore. This flag is ignored. Defaults to False.
+    Returns:
+        str: Status message indicating the result.
+    """
+
+    permissions = ToolPermissions(read=True, write=True)
+    tool_name = "move_file"
+
+    def run(
+        self,
+        src_path: str,
+        dest_path: str,
+        overwrite: bool = False,
+        backup: bool = False,
+    ) -> str:
+        src = expand_path(src_path)
+        dest = expand_path(dest_path)
+        original_src = src_path
+        original_dest = dest_path
+        disp_src = display_path(original_src)
+        disp_dest = display_path(original_dest)
+        backup_path = None
+
+        valid, is_src_file, is_src_dir, err_msg = self._validate_source(src, disp_src)
+        if not valid:
+            return err_msg
+
+        dest_result = self._handle_destination(dest, disp_dest, overwrite, backup)
+        if dest_result is not None:
+            backup_path, err_msg = dest_result
+            if err_msg:
+                return err_msg
+
+        try:
+            self.report_action(
+                tr(
+                    "📝 Moving from '{disp_src}' to '{disp_dest}' ...",
+                    disp_src=disp_src,
+                    disp_dest=disp_dest,
+                ),
+                ReportAction.UPDATE,
+            )
+            shutil.move(src, dest)
+            self.report_success(tr("✅ Move complete."))
+            msg = tr("✅ Move complete.")
+
+            return msg
+        except Exception as e:
+            self.report_error(tr("❌ Error moving: {error}", error=e))
+            return tr("❌ Error moving: {error}", error=e)
+
+    def _validate_source(self, src, disp_src):
+        if not os.path.exists(src):
+            self.report_error(
+                tr("❌ Source '{disp_src}' does not exist.", disp_src=disp_src)
+            )
+            return (
+                False,
+                False,
+                False,
+                tr("❌ Source '{disp_src}' does not exist.", disp_src=disp_src),
+            )
+        is_src_file = os.path.isfile(src)
+        is_src_dir = os.path.isdir(src)
+        if not (is_src_file or is_src_dir):
+            self.report_error(
+                tr(
+                    "❌ Source path '{disp_src}' is neither a file nor a directory.",
+                    disp_src=disp_src,
+                )
+            )
+            return (
+                False,
+                False,
+                False,
+                tr(
+                    "❌ Source path '{disp_src}' is neither a file nor a directory.",
+                    disp_src=disp_src,
+                ),
+            )
+        return True, is_src_file, is_src_dir, None
+
+    def _handle_destination(self, dest, disp_dest, overwrite, backup):
+        backup_path = None
+        if os.path.exists(dest):
+            if not overwrite:
+                self.report_error(
+                    tr(
+                        "❗ Destination '{disp_dest}' exists and overwrite is False.",
+                        disp_dest=disp_dest,
+                    ),
+                    ReportAction.UPDATE,
+                )
+                return None, tr(
+                    "❗ Destination '{disp_dest}' already exists and overwrite is False.",
+                    disp_dest=disp_dest,
+                )
+
+            try:
+                if os.path.isfile(dest):
+                    os.remove(dest)
+                elif os.path.isdir(dest):
+                    shutil.rmtree(dest)
+            except Exception as e:
+                self.report_error(
+                    tr("❌ Error removing destination before move: {error}", error=e),
+                    ReportAction.UPDATE,
+                )
+                return None, tr(
+                    "❌ Error removing destination before move: {error}", error=e
+                )
+        return backup_path, None

janito/{plugins/tools/core → tools/adapters/local}/python_code_run.py

@@ -5,12 +5,12 @@ import tempfile
 import threading
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
-from .decorators import register_core_tool
+from janito.tools.adapters.local.adapter import register_local_tool
 from janito.i18n import tr
 
 
-@register_core_tool
-class PythonCodeRun(ToolBase):
+@register_local_tool
+class PythonCodeRunTool(ToolBase):
     """
     Tool to execute Python code by passing it to the interpreter via standard input (stdin).
 
@@ -93,9 +93,6 @@ class PythonCodeRun(ToolBase):
         def stream_output(stream, file_obj, report_func, count_func):
             nonlocal stdout_lines, stderr_lines
             for line in stream:
-                # Check for cancellation
-                if hasattr(self, '_cancel_event') and self._cancel_event.is_set():
-                    break
                 file_obj.write(line)
                 file_obj.flush()
                 report_func(line.rstrip("\r\n"))
@@ -104,11 +101,6 @@ class PythonCodeRun(ToolBase):
                 else:
                     stderr_lines += 1
 
-        # Set up cancellation event
-        from janito.llm.cancellation_manager import get_cancellation_manager
-        cancel_manager = get_cancellation_manager()
-        self._cancel_event = cancel_manager.get_current_cancel_event()
-        
         stdout_thread = threading.Thread(
             target=stream_output,
             args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
@@ -119,18 +111,10 @@ class PythonCodeRun(ToolBase):
         )
         stdout_thread.start()
         stderr_thread.start()
-        
-        try:
-            process.stdin.write(code)
-            process.stdin.close()
-            stdout_thread.join()
-            stderr_thread.join()
-        except Exception as e:
-            # Handle cancellation or other errors
-            if self._cancel_event and self._cancel_event.is_set():
-                process.kill()
-                self.report_warning(tr("Code execution cancelled by user"), ReportAction.EXECUTE)
-            raise
+        process.stdin.write(code)
+        process.stdin.close()
+        stdout_thread.join()
+        stderr_thread.join()
         return stdout_lines, stderr_lines
 
     def _wait_for_process(self, process, timeout):

janito/{plugins/tools/core → tools/adapters/local}/python_command_run.py

@@ -5,12 +5,12 @@ import tempfile
 import threading
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
-from .decorators import register_core_tool
+from janito.tools.adapters.local.adapter import register_local_tool
 from janito.i18n import tr
 
 
-@register_core_tool
-class PythonCommandRun(ToolBase):
+@register_local_tool
+class PythonCommandRunTool(ToolBase):
     """
     Tool to execute Python code using the `python -c` command-line flag.
 
@@ -92,9 +92,6 @@ class PythonCommandRun(ToolBase):
         def stream_output(stream, file_obj, report_func, count_func):
             nonlocal stdout_lines, stderr_lines
             for line in stream:
-                # Check for cancellation
-                if hasattr(self, '_cancel_event') and self._cancel_event.is_set():
-                    break
                 file_obj.write(line)
                 file_obj.flush()
                 from janito.tools.tool_base import ReportAction
@@ -105,11 +102,6 @@ class PythonCommandRun(ToolBase):
                 else:
                     stderr_lines += 1
 
-        # Set up cancellation event
-        from janito.llm.cancellation_manager import get_cancellation_manager
-        cancel_manager = get_cancellation_manager()
-        self._cancel_event = cancel_manager.get_current_cancel_event()
-        
         stdout_thread = threading.Thread(
             target=stream_output,
             args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
@@ -120,16 +112,8 @@ class PythonCommandRun(ToolBase):
         )
         stdout_thread.start()
         stderr_thread.start()
-        
-        try:
-            stdout_thread.join()
-            stderr_thread.join()
-        except Exception as e:
-            # Handle cancellation
-            if self._cancel_event and self._cancel_event.is_set():
-                process.kill()
-                self.report_warning(tr("Code execution cancelled by user"), ReportAction.EXECUTE)
-            raise
+        stdout_thread.join()
+        stderr_thread.join()
         return stdout_lines, stderr_lines
 
     def _wait_for_process(self, process, timeout):

janito/{plugins/tools/core → tools/adapters/local}/python_file_run.py

@@ -5,12 +5,12 @@ import tempfile
 import threading
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
-from .decorators import register_core_tool
+from janito.tools.adapters.local.adapter import register_local_tool
 from janito.i18n import tr
 
 
-@register_core_tool
-class PythonFileRun(ToolBase):
+@register_local_tool
+class PythonFileRunTool(ToolBase):
     """
     Tool to execute a specified Python script file.
 
@@ -92,9 +92,6 @@ class PythonFileRun(ToolBase):
         def stream_output(stream, file_obj, report_func, count_func):
             nonlocal stdout_lines, stderr_lines
             for line in stream:
-                # Check for cancellation
-                if hasattr(self, '_cancel_event') and self._cancel_event.is_set():
-                    break
                 file_obj.write(line)
                 file_obj.flush()
                 # Always supply a default action for stdout/stderr reporting
@@ -106,11 +103,6 @@ class PythonFileRun(ToolBase):
                 else:
                     stderr_lines += 1
 
-        # Set up cancellation event
-        from janito.llm.cancellation_manager import get_cancellation_manager
-        cancel_manager = get_cancellation_manager()
-        self._cancel_event = cancel_manager.get_current_cancel_event()
-        
         stdout_thread = threading.Thread(
             target=stream_output,
             args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
@@ -121,16 +113,8 @@ class PythonFileRun(ToolBase):
         )
         stdout_thread.start()
         stderr_thread.start()
-        
-        try:
-            stdout_thread.join()
-            stderr_thread.join()
-        except Exception as e:
-            # Handle cancellation
-            if self._cancel_event and self._cancel_event.is_set():
-                process.kill()
-                self.report_warning(tr("File execution cancelled by user"), ReportAction.EXECUTE)
-            raise
+        stdout_thread.join()
+        stderr_thread.join()
         return stdout_lines, stderr_lines
 
     def _wait_for_process(self, process, timeout):

janito/tools/adapters/local/remove_file.py

@@ -0,0 +1,58 @@
+import os
+from janito.tools.path_utils import expand_path
+import shutil
+from janito.tools.adapters.local.adapter import register_local_tool
+
+from janito.tools.tool_utils import display_path
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.i18n import tr
+
+
+@register_local_tool
+class RemoveFileTool(ToolBase):
+    """
+    Remove a file at the specified path.
+
+    Args:
+        path (str): Path to the file to remove.
+        backup (bool, optional): Deprecated. Backups are no longer created. Flag ignored.
+    Returns:
+        str: Status message indicating the result. Example:
+            - "			 Successfully removed the file at ..."
+            - "			 Cannot remove file: ..."
+    """
+
+    permissions = ToolPermissions(write=True)
+    tool_name = "remove_file"
+
+    def run(self, path: str, backup: bool = False) -> str:
+        path = expand_path(path)
+        disp_path = display_path(path)
+
+        # Report initial info about what is going to be removed
+        self.report_action(
+            tr("🗑️ Remove file '{disp_path}' ...", disp_path=disp_path),
+            ReportAction.DELETE,
+        )
+        if not os.path.exists(path):
+            self.report_error(tr("❌ File does not exist."), ReportAction.DELETE)
+            return tr("❌ File does not exist.")
+        if not os.path.isfile(path):
+            self.report_error(tr("❌ Path is not a file."), ReportAction.DELETE)
+            return tr("❌ Path is not a file.")
+        try:
+
+            os.remove(path)
+            self.report_success(tr("✅ File removed"), ReportAction.DELETE)
+            msg = tr(
+                "✅ Successfully removed the file at '{disp_path}'.",
+                disp_path=disp_path,
+            )
+
+            return msg
+        except Exception as e:
+            self.report_error(
+                tr("❌ Error removing file: {error}", error=e), ReportAction.DELETE
+            )
+            return tr("❌ Error removing file: {error}", error=e)

janito/{plugins/tools/core → tools/adapters/local}/replace_text_in_file.py

@@ -1,14 +1,14 @@
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
-from .decorators import register_core_tool
+from janito.tools.adapters.local.adapter import register_local_tool
 from janito.i18n import tr
 import shutil
 import re
-from .validate_file_syntax.core import validate_file_syntax
+from janito.tools.adapters.local.validate_file_syntax.core import validate_file_syntax
 
 
-@register_core_tool
-class ReplaceTextInFile(ToolBase):
+@register_local_tool
+class ReplaceTextInFileTool(ToolBase):
     """
     Replace exact occurrences of a given text in a file.
 

janito/{plugins/tools/core → tools/adapters/local}/run_bash_command.py

@@ -1,6 +1,6 @@
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
-from .decorators import register_core_tool
+from janito.tools.adapters.local.adapter import register_local_tool
 from janito.i18n import tr
 import subprocess
 import tempfile
@@ -9,8 +9,8 @@ import os
 import threading
 
 
-@register_core_tool
-class RunBashCommand(ToolBase):
+@register_local_tool
+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).

janito/{plugins/tools/core → tools/adapters/local}/run_powershell_command.py

@@ -1,6 +1,6 @@
 from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
-from .decorators import register_core_tool
+from janito.tools.adapters.local.adapter import register_local_tool
 from janito.i18n import tr
 import subprocess
 import os
@@ -9,8 +9,8 @@ import tempfile
 import threading
 
 
-@register_core_tool
-class RunPowershellCommand(ToolBase):
+@register_local_tool
+class RunPowershellCommandTool(ToolBase):
     """
     Execute a non-interactive command using the PowerShell shell and capture live output.
     This tool explicitly invokes 'powershell.exe' (on Windows) or 'pwsh' (on other platforms if available).