janito 2.6.1__py3-none-any.whl → 2.8.0__py3-none-any.whl

janito/tools/adapters/local/__init__.py

@@ -1,66 +1,67 @@
-from .adapter import LocalToolsAdapter
-
-from .ask_user import AskUserTool
-from .copy_file import CopyFileTool
-from .create_directory import CreateDirectoryTool
-from .create_file import CreateFileTool
-from .fetch_url import FetchUrlTool
-from .find_files import FindFilesTool
-from .view_file import ViewFileTool
-from .read_files import ReadFilesTool
-from .move_file import MoveFileTool
-from .open_url import OpenUrlTool
-from .open_html_in_browser import OpenHtmlInBrowserTool
-from .python_code_run import PythonCodeRunTool
-from .python_command_run import PythonCommandRunTool
-from .python_file_run import PythonFileRunTool
-from .remove_directory import RemoveDirectoryTool
-from .remove_file import RemoveFileTool
-from .replace_text_in_file import ReplaceTextInFileTool
-from .run_bash_command import RunBashCommandTool
-from .run_powershell_command import RunPowershellCommandTool
-from .get_file_outline.core import GetFileOutlineTool
-from .get_file_outline.search_outline import SearchOutlineTool
-from .search_text.core import SearchTextTool
-from .validate_file_syntax.core import ValidateFileSyntaxTool
-
-from janito.tools.tool_base import ToolPermissions
-import os
-from janito.tools.permissions import get_global_allowed_permissions
-
-# Singleton tools adapter with all standard tools registered
-local_tools_adapter = LocalToolsAdapter(workdir=os.getcwd())
-
-def get_local_tools_adapter(workdir=None):
-    return LocalToolsAdapter(workdir=workdir or os.getcwd())
-
-# Register tools
-for tool_class in [
-    AskUserTool,
-    CopyFileTool,
-    CreateDirectoryTool,
-    CreateFileTool,
-    FetchUrlTool,
-    FindFilesTool,
-    ViewFileTool,
-    ReadFilesTool,
-    MoveFileTool,
-    OpenUrlTool,
-    OpenHtmlInBrowserTool,
-    PythonCodeRunTool,
-    PythonCommandRunTool,
-    PythonFileRunTool,
-    RemoveDirectoryTool,
-    RemoveFileTool,
-    ReplaceTextInFileTool,
-    RunBashCommandTool,
-    RunPowershellCommandTool,
-    GetFileOutlineTool,
-    SearchOutlineTool,
-    SearchTextTool,
-    ValidateFileSyntaxTool,
-]:
-    local_tools_adapter.register_tool(tool_class)
-
-# DEBUG: Print registered tools at startup
-
+from .adapter import LocalToolsAdapter
+
+from .ask_user import AskUserTool
+from .copy_file import CopyFileTool
+from .create_directory import CreateDirectoryTool
+from .create_file import CreateFileTool
+from .fetch_url import FetchUrlTool
+from .find_files import FindFilesTool
+from .view_file import ViewFileTool
+from .read_files import ReadFilesTool
+from .move_file import MoveFileTool
+from .open_url import OpenUrlTool
+from .open_html_in_browser import OpenHtmlInBrowserTool
+from .python_code_run import PythonCodeRunTool
+from .python_command_run import PythonCommandRunTool
+from .python_file_run import PythonFileRunTool
+from .remove_directory import RemoveDirectoryTool
+from .remove_file import RemoveFileTool
+from .replace_text_in_file import ReplaceTextInFileTool
+from .run_bash_command import RunBashCommandTool
+from .run_powershell_command import RunPowershellCommandTool
+from .get_file_outline.core import GetFileOutlineTool
+from .get_file_outline.search_outline import SearchOutlineTool
+from .search_text.core import SearchTextTool
+from .validate_file_syntax.core import ValidateFileSyntaxTool
+
+from janito.tools.tool_base import ToolPermissions
+import os
+from janito.tools.permissions import get_global_allowed_permissions
+
+# Singleton tools adapter with all standard tools registered
+local_tools_adapter = LocalToolsAdapter(workdir=os.getcwd())
+
+
+def get_local_tools_adapter(workdir=None):
+    return LocalToolsAdapter(workdir=workdir or os.getcwd())
+
+
+# Register tools
+for tool_class in [
+    AskUserTool,
+    CopyFileTool,
+    CreateDirectoryTool,
+    CreateFileTool,
+    FetchUrlTool,
+    FindFilesTool,
+    ViewFileTool,
+    ReadFilesTool,
+    MoveFileTool,
+    OpenUrlTool,
+    OpenHtmlInBrowserTool,
+    PythonCodeRunTool,
+    PythonCommandRunTool,
+    PythonFileRunTool,
+    RemoveDirectoryTool,
+    RemoveFileTool,
+    ReplaceTextInFileTool,
+    RunBashCommandTool,
+    RunPowershellCommandTool,
+    GetFileOutlineTool,
+    SearchOutlineTool,
+    SearchTextTool,
+    ValidateFileSyntaxTool,
+]:
+    local_tools_adapter.register_tool(tool_class)
+
+# DEBUG: Print registered tools at startup

janito/tools/adapters/local/adapter.py

@@ -40,6 +40,7 @@ class LocalToolsAdapter(ToolsAdapter):
         # to UI components even if the caller did not supply a custom bus.
         if event_bus is None:
             from janito.event_bus.bus import event_bus as global_event_bus
+
             event_bus = global_event_bus
 
         super().__init__(tools=tools, event_bus=event_bus)
@@ -48,6 +49,7 @@ class LocalToolsAdapter(ToolsAdapter):
         self._tools: Dict[str, Dict[str, Any]] = {}
 
         import os
+
         self.workdir = workdir or os.getcwd()
         # Ensure *some* workdir is set – fallback to CWD.
         if not self.workdir:
@@ -93,27 +95,39 @@ class LocalToolsAdapter(ToolsAdapter):
     # Lookup helpers used by ToolsAdapterBase
     # ------------------------------------------------------------------
     def get_tool(self, name: str):
-        return self._tools[name]["instance"] if name in self._tools else None
+        from janito.tools.disabled_tools import is_tool_disabled
+
+        if name in self._tools and not is_tool_disabled(name):
+            return self._tools[name]["instance"]
+        return None
 
     def list_tools(self):
+        from janito.tools.disabled_tools import is_tool_disabled
+
         return [
             name
             for name, entry in self._tools.items()
-            if self.is_tool_allowed(entry["instance"])
+            if self.is_tool_allowed(entry["instance"]) and not is_tool_disabled(name)
         ]
 
     def get_tool_classes(self):
+        from janito.tools.disabled_tools import is_tool_disabled
+
         return [
             entry["class"]
             for entry in self._tools.values()
             if self.is_tool_allowed(entry["instance"])
+            and not is_tool_disabled(entry["instance"].tool_name)
         ]
 
     def get_tools(self):
+        from janito.tools.disabled_tools import is_tool_disabled
+
         return [
             entry["instance"]
             for entry in self._tools.values()
             if self.is_tool_allowed(entry["instance"])
+            and not is_tool_disabled(entry["instance"].tool_name)
         ]
 
     # ------------------------------------------------------------------
@@ -125,7 +139,9 @@ class LocalToolsAdapter(ToolsAdapter):
             raise TypeError(f"Tool '{tool}' must implement a callable 'run' method.")
         tool_name = getattr(tool, "tool_name", None)
         if not tool_name or not isinstance(tool_name, str):
-            raise ValueError(f"Tool '{tool}' must provide a 'tool_name' (str) attribute.")
+            raise ValueError(
+                f"Tool '{tool}' must provide a 'tool_name' (str) attribute."
+            )
         if tool_name in self._tools:
             raise ValueError(f"Tool '{tool_name}' is already registered.")
         self._tools[tool_name] = {
@@ -139,6 +155,7 @@ class LocalToolsAdapter(ToolsAdapter):
 # Decorator helper for quick registration of local tools
 # -------------------------------------------------------------------------
 
+
 def register_local_tool(tool=None):
     """Class decorator that registers the tool on the *singleton* adapter.
 
@@ -150,7 +167,7 @@ def register_local_tool(tool=None):
     """
 
     def decorator(cls):
-                # Register the tool on a *fresh* adapter instance to avoid circular
+        # Register the tool on a *fresh* adapter instance to avoid circular
         # import issues during package initialisation.  This keeps behaviour
         # identical to the original implementation while still allowing
         # immediate use via the singleton in janito.tools.adapters.local.

janito/tools/adapters/local/ask_user.py

@@ -27,6 +27,7 @@ class AskUserTool(ToolBase):
             - "No"
             - "Some detailed answer..."
     """
+
     permissions = ToolPermissions(read=True)
     tool_name = "ask_user"
 

janito/tools/adapters/local/copy_file.py

@@ -21,6 +21,7 @@ class CopyFileTool(ToolBase):
     Returns:
         str: Status string for each copy operation.
     """
+
     permissions = ToolPermissions(read=True, write=True)
     tool_name = "copy_file"
 

janito/tools/adapters/local/create_directory.py

@@ -18,6 +18,7 @@ class CreateDirectoryTool(ToolBase):
             - "5c5 Successfully created the directory at ..."
             - "5d7 Cannot create directory: ..."
     """
+
     permissions = ToolPermissions(write=True)
     tool_name = "create_directory"
 

janito/tools/adapters/local/create_file.py

@@ -25,6 +25,7 @@ class CreateFileTool(ToolBase):
 
     Note: Syntax validation is automatically performed after this operation.
     """
+
     permissions = ToolPermissions(write=True)
     tool_name = "create_file"
 

janito/tools/adapters/local/delete_text_in_file.py

@@ -19,6 +19,7 @@ class DeleteTextInFileTool(ToolBase):
     Returns:
         str: Status message indicating the result.
     """
+
     permissions = ToolPermissions(read=True, write=True)
     tool_name = "delete_text_in_file"
 
@@ -62,7 +63,7 @@ class DeleteTextInFileTool(ToolBase):
             return tr(
                 "Deleted {count} block(s) between markers in {path}. ",
                 count=deleted_blocks,
-                path=path
+                path=path,
             ) + (f"\n{validation_result}" if validation_result else "")
         except Exception as e:
             self.report_error(tr(" ❌ Error: {error}", error=e), ReportAction.REPLACE)

janito/tools/adapters/local/fetch_url.py

@@ -21,6 +21,7 @@ class FetchUrlTool(ToolBase):
             - "No lines found for the provided search strings."
             - "Warning: Empty URL provided. Operation skipped."
     """
+
     permissions = ToolPermissions(read=True)
     tool_name = "fetch_url"
 

janito/tools/adapters/local/find_files.py

@@ -61,7 +61,9 @@ class FindFilesTool(ToolBase):
                     break
         return dir_output
 
-    def _handle_directory_path(self, directory, patterns, max_depth, include_gitignored):
+    def _handle_directory_path(
+        self, directory, patterns, max_depth, include_gitignored
+    ):
         dir_output = set()
         for root, dirs, files in walk_dir_with_gitignore(
             directory,
@@ -73,9 +75,7 @@ class FindFilesTool(ToolBase):
                     dir_output.update(self._match_directories(root, dirs, pat))
                 else:
                     dir_output.update(self._match_files(root, files, pat))
-                    dir_output.update(
-                        self._match_dirs_without_slash(root, dirs, pat)
-                    )
+                    dir_output.update(self._match_dirs_without_slash(root, dirs, pat))
         return dir_output
 
     def _report_search(self, pattern, disp_path, depth_msg):
@@ -131,9 +131,10 @@ class FindFilesTool(ToolBase):
             if os.path.isfile(directory):
                 dir_output = self._handle_path(directory, patterns)
             elif os.path.isdir(directory):
-                dir_output = self._handle_directory_path(directory, patterns, max_depth, include_gitignored)
+                dir_output = self._handle_directory_path(
+                    directory, patterns, max_depth, include_gitignored
+                )
             self._report_success(len(dir_output))
             results.extend(self._format_output(directory, dir_output))
         result = "\n".join(results)
         return result
-

janito/tools/adapters/local/get_file_outline/core.py

@@ -20,6 +20,7 @@ class GetFileOutlineTool(ToolBase):
     Args:
         path (str): Path to the file to outline.
     """
+
     permissions = ToolPermissions(read=True)
     tool_name = "get_file_outline"
 

janito/tools/adapters/local/get_file_outline/java_outline.py

@@ -1,6 +1,7 @@
 import re
 from typing import List, Dict
 
+
 def parse_java_outline(lines: List[str]) -> List[Dict]:
     """
     Parses Java source code lines and extracts classes and methods with their signatures.
@@ -9,19 +10,23 @@ def parse_java_outline(lines: List[str]) -> List[Dict]:
     outline = []
     class_pattern = re.compile(r"\bclass\s+(\w+)(\s*<[^>]+>)?")
     # Match methods with or without visibility modifiers (including package-private)
-    method_pattern = re.compile(r"^(?:\s*(public|protected|private)\s+)?(?:static\s+)?([\w<>\[\]]+)\s+(\w+)\s*\(([^)]*)\)")
+    method_pattern = re.compile(
+        r"^(?:\s*(public|protected|private)\s+)?(?:static\s+)?([\w<>\[\]]+)\s+(\w+)\s*\(([^)]*)\)"
+    )
     current_class = None
     for idx, line in enumerate(lines, 1):
         class_match = class_pattern.search(line)
         if class_match:
             class_name = class_match.group(1)
             generics = class_match.group(2) or ""
-            outline.append({
-                "type": "class",
-                "name": class_name,
-                "generics": generics.strip("<>") if generics else None,
-                "line": idx
-            })
+            outline.append(
+                {
+                    "type": "class",
+                    "name": class_name,
+                    "generics": generics.strip("<>") if generics else None,
+                    "line": idx,
+                }
+            )
             current_class = class_name
         else:
             method_match = method_pattern.search(line)
@@ -29,12 +34,14 @@ def parse_java_outline(lines: List[str]) -> List[Dict]:
                 return_type = method_match.group(2)
                 method_name = method_match.group(3)
                 params = method_match.group(4)
-                outline.append({
-                    "type": "method",
-                    "class": current_class,
-                    "name": method_name,
-                    "return_type": return_type,
-                    "parameters": params.strip(),
-                    "line": idx
-                })
+                outline.append(
+                    {
+                        "type": "method",
+                        "class": current_class,
+                        "name": method_name,
+                        "return_type": return_type,
+                        "parameters": params.strip(),
+                        "line": idx,
+                    }
+                )
     return outline

janito/tools/adapters/local/get_file_outline/search_outline.py

@@ -11,6 +11,7 @@ class SearchOutlineTool(ToolBase):
     Returns:
         str: Outline search result or status message.
     """
+
     permissions = ToolPermissions(read=True)
     tool_name = "search_outline"
 

janito/tools/adapters/local/move_file.py

@@ -20,6 +20,7 @@ class MoveFileTool(ToolBase):
     Returns:
         str: Status message indicating the result.
     """
+
     permissions = ToolPermissions(read=True, write=True)
     tool_name = "move_file"
 
@@ -55,7 +56,7 @@ class MoveFileTool(ToolBase):
                     disp_src=disp_src,
                     disp_dest=disp_dest,
                 ),
-                ReportAction.CREATE,
+                ReportAction.UPDATE,
             )
             shutil.move(src, dest)
             self.report_success(tr("✅ Move complete."))
@@ -106,7 +107,7 @@ class MoveFileTool(ToolBase):
                         "❗ Destination '{disp_dest}' exists and overwrite is False.",
                         disp_dest=disp_dest,
                     ),
-                    ReportAction.MOVE,
+                    ReportAction.UPDATE,
                 )
                 return None, tr(
                     "❗ Destination '{disp_dest}' already exists and overwrite is False.",
@@ -121,7 +122,7 @@ class MoveFileTool(ToolBase):
             except Exception as e:
                 self.report_error(
                     tr("❌ Error removing destination before move: {error}", error=e),
-                    ReportAction.MOVE,
+                    ReportAction.UPDATE,
                 )
                 return None, tr(
                     "❌ Error removing destination before move: {error}", error=e

janito/tools/adapters/local/open_html_in_browser.py

@@ -5,6 +5,7 @@ from janito.tools.tool_base import ToolBase, ToolPermissions
 from janito.report_events import ReportAction
 from janito.i18n import tr
 
+
 @register_local_tool
 class OpenHtmlInBrowserTool(ToolBase):
     """
@@ -15,6 +16,7 @@ class OpenHtmlInBrowserTool(ToolBase):
     Returns:
         str: Status message indicating the result.
     """
+
     permissions = ToolPermissions(read=True)
     tool_name = "open_html_in_browser"
 
@@ -25,15 +27,23 @@ class OpenHtmlInBrowserTool(ToolBase):
         if not os.path.isfile(path):
             self.report_error(tr("❗ File does not exist: {path}", path=path))
             return tr("Warning: File does not exist: {path}", path=path)
-        if not path.lower().endswith(('.html', '.htm')):
+        if not path.lower().endswith((".html", ".htm")):
             self.report_warning(tr("⚠️ Not an HTML file: {path}", path=path))
             return tr("Warning: Not an HTML file: {path}", path=path)
-        url = 'file://' + os.path.abspath(path)
-        self.report_action(tr("📖 Opening HTML file in browser: {path}", path=path), ReportAction.READ)
+        url = "file://" + os.path.abspath(path)
+        self.report_action(
+            tr("📖 Opening HTML file in browser: {path}", path=path), ReportAction.READ
+        )
         try:
             webbrowser.open(url)
         except Exception as err:
-            self.report_error(tr("❗ Error opening HTML file: {path}: {err}", path=path, err=str(err)))
-            return tr("Warning: Error opening HTML file: {path}: {err}", path=path, err=str(err))
+            self.report_error(
+                tr("❗ Error opening HTML file: {path}: {err}", path=path, err=str(err))
+            )
+            return tr(
+                "Warning: Error opening HTML file: {path}: {err}",
+                path=path,
+                err=str(err),
+            )
         self.report_success(tr("✅ HTML file opened in browser: {path}", path=path))
         return tr("HTML file opened in browser: {path}", path=path)

janito/tools/adapters/local/open_url.py

@@ -15,6 +15,7 @@ class OpenUrlTool(ToolBase):
     Returns:
         str: Status message indicating the result.
     """
+
     permissions = ToolPermissions(read=True)
     tool_name = "open_url"
 

janito/tools/adapters/local/python_code_run.py

@@ -21,6 +21,7 @@ class PythonCodeRunTool(ToolBase):
     Returns:
         str: Output and status message, or file paths/line counts if output is large.
     """
+
     permissions = ToolPermissions(execute=True)
     tool_name = "python_code_run"
 

janito/tools/adapters/local/python_command_run.py

@@ -21,6 +21,7 @@ class PythonCommandRunTool(ToolBase):
     Returns:
         str: Output and status message, or file paths/line counts if output is large.
     """
+
     permissions = ToolPermissions(execute=True)
     tool_name = "python_command_run"
 

janito/tools/adapters/local/python_file_run.py

@@ -21,6 +21,7 @@ class PythonFileRunTool(ToolBase):
     Returns:
         str: Output and status message, or file paths/line counts if output is large.
     """
+
     permissions = ToolPermissions(execute=True)
     tool_name = "python_file_run"
 

janito/tools/adapters/local/read_files.py

@@ -1,40 +1,55 @@
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.tools.adapters.local.adapter import register_local_tool
-from janito.tools.tool_utils import pluralize
-from janito.i18n import tr
-
-@register_local_tool
-class ReadFilesTool(ToolBase):
-    """
-    Read all text content from multiple files.
-
-    Args:
-        paths (list[str]): List of file paths to read.
-
-    Returns:
-        str: Concatenated content of all files, each prefixed by a header with the file name. If a file cannot be read, an error message is included for that file.
-    """
-    permissions = ToolPermissions(read=True)
-    tool_name = "read_files"
-
-    def run(self, paths: list[str]) -> str:
-        from janito.tools.tool_utils import display_path
-        import os
-        results = []
-        for path in paths:
-            disp_path = display_path(path)
-            self.report_action(tr("📖 Read '{disp_path}'", disp_path=disp_path), ReportAction.READ)
-            if not os.path.isfile(path):
-                self.report_warning(tr("❗ not found: {disp_path}", disp_path=disp_path))
-                results.append(f"--- File: {disp_path} (not found) ---\n")
-                continue
-            try:
-                with open(path, "r", encoding="utf-8", errors="replace") as f:
-                    content = f.read()
-                results.append(f"--- File: {disp_path} ---\n{content}\n")
-                self.report_success(tr("✅ Read {disp_path}", disp_path=disp_path))
-            except Exception as e:
-                self.report_error(tr(" ❌ Error reading {disp_path}: {error}", disp_path=disp_path, error=e))
-                results.append(f"--- File: {disp_path} (error) ---\nError reading file: {e}\n")
-        return "\n".join(results)
+from janito.tools.tool_base import ToolBase, ToolPermissions
+from janito.report_events import ReportAction
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.tools.tool_utils import pluralize
+from janito.i18n import tr
+
+
+@register_local_tool
+class ReadFilesTool(ToolBase):
+    """
+    Read all text content from multiple files.
+
+    Args:
+        paths (list[str]): List of file paths to read.
+
+    Returns:
+        str: Concatenated content of all files, each prefixed by a header with the file name. If a file cannot be read, an error message is included for that file.
+    """
+
+    permissions = ToolPermissions(read=True)
+    tool_name = "read_files"
+
+    def run(self, paths: list[str]) -> str:
+        from janito.tools.tool_utils import display_path
+        import os
+
+        results = []
+        for path in paths:
+            disp_path = display_path(path)
+            self.report_action(
+                tr("📖 Read '{disp_path}'", disp_path=disp_path), ReportAction.READ
+            )
+            if not os.path.isfile(path):
+                self.report_warning(
+                    tr("❗ not found: {disp_path}", disp_path=disp_path)
+                )
+                results.append(f"--- File: {disp_path} (not found) ---\n")
+                continue
+            try:
+                with open(path, "r", encoding="utf-8", errors="replace") as f:
+                    content = f.read()
+                results.append(f"--- File: {disp_path} ---\n{content}\n")
+                self.report_success(tr("✅ Read {disp_path}", disp_path=disp_path))
+            except Exception as e:
+                self.report_error(
+                    tr(
+                        " ❌ Error reading {disp_path}: {error}",
+                        disp_path=disp_path,
+                        error=e,
+                    )
+                )
+                results.append(
+                    f"--- File: {disp_path} (error) ---\nError reading file: {e}\n"
+                )
+        return "\n".join(results)

janito/tools/adapters/local/remove_directory.py

@@ -21,6 +21,7 @@ class RemoveDirectoryTool(ToolBase):
             - "Directory removed: /path/to/dir"
             - "Error removing directory: <error message>"
     """
+
     permissions = ToolPermissions(write=True)
     tool_name = "remove_directory"
 

janito/tools/adapters/local/remove_file.py

@@ -21,6 +21,7 @@ class RemoveFileTool(ToolBase):
             - "			 Successfully removed the file at ..."
             - "			 Cannot remove file: ..."
     """
+
     permissions = ToolPermissions(write=True)
     tool_name = "remove_file"
 

janito/tools/adapters/local/replace_text_in_file.py

@@ -28,6 +28,7 @@ class ReplaceTextInFileTool(ToolBase):
             - "No changes made. [Warning: Search text not found in file] Please review the original file."
             - "Error replacing text: <error message>"
     """
+
     permissions = ToolPermissions(read=True, write=True)
     tool_name = "replace_text_in_file"
 
@@ -85,9 +86,9 @@ class ReplaceTextInFileTool(ToolBase):
                 line_delta_str,
                 replace_all,
             )
-            return self._format_final_msg(
-                path, warning, match_info, details
-            ) + (f"\n{validation_result}" if validation_result else "")
+            return self._format_final_msg(path, warning, match_info, details) + (
+                f"\n{validation_result}" if validation_result else ""
+            )
         except Exception as e:
             self.report_error(tr(" ❌ Error"), ReportAction.REPLACE)
             return tr("Error replacing text: {error}", error=e)