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

janito/providers/openai/provider.py

@@ -14,11 +14,10 @@ unavailable_reason = OpenAIModelDriver.unavailable_reason
 
 class OpenAIProvider(LLMProvider):
     name = "openai"
-    maintainer = "João Pinto <lamego.pinto@gmail.com>"
+    NAME = "openai"
+    MAINTAINER = "João Pinto <lamego.pinto@gmail.com>"
     MODEL_SPECS = MODEL_SPECS
-    DEFAULT_MODEL = (
-        "gpt-4.1"  # Options: gpt-4.1, gpt-4o, o3-mini, o4-mini, 
-    )
+    DEFAULT_MODEL = "gpt-4.1"  # Options: gpt-4.1, gpt-4o, o3-mini, o4-mini,
 
     def __init__(
         self, auth_manager: LLMAuthManager = None, config: LLMDriverConfig = None
@@ -31,7 +30,7 @@ class OpenAIProvider(LLMProvider):
             self._driver = None
         else:
             self.auth_manager = auth_manager or LLMAuthManager()
-            self._api_key = self.auth_manager.get_credentials(type(self).name)
+            self._api_key = self.auth_manager.get_credentials(type(self).NAME)
             self._tools_adapter = get_local_tools_adapter()
             self._driver_config = config or LLMDriverConfig(model=None)
             if not self._driver_config.model:
@@ -77,7 +76,7 @@ class OpenAIProvider(LLMProvider):
         Creates and returns a new OpenAIModelDriver instance with input/output queues.
         """
         driver = OpenAIModelDriver(
-            tools_adapter=self._tools_adapter, provider_name=self.name
+            tools_adapter=self._tools_adapter, provider_name=self.NAME
         )
         driver.config = self._driver_config
         # NOTE: The caller is responsible for calling driver.start() if background processing is needed.
@@ -108,4 +107,4 @@ class OpenAIProvider(LLMProvider):
         return self._tools_adapter.execute_by_name(tool_name, *args, **kwargs)
 
 
-LLMProviderRegistry.register(OpenAIProvider.name, OpenAIProvider)
+LLMProviderRegistry.register(OpenAIProvider.NAME, OpenAIProvider)

janito/tools/__init__.py

@@ -7,6 +7,7 @@ from janito.tools.adapters.local import (
 def get_local_tools_adapter(workdir=None, allowed_permissions=None):
     # Use set_verbose_tools on the returned adapter to set verbosity as needed
     import os
+
     if workdir is not None and not os.path.exists(workdir):
         os.makedirs(workdir, exist_ok=True)
     # Permissions are now managed globally; ignore allowed_permissions argument except for backward compatibility
@@ -16,6 +17,7 @@ def get_local_tools_adapter(workdir=None, allowed_permissions=None):
     if workdir is not None:
         try:
             import os
+
             if not os.path.exists(workdir):
                 os.makedirs(workdir, exist_ok=True)
             os.chdir(workdir)

janito/tools/adapters/local/__init__.py

@@ -31,9 +31,11 @@ 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,
@@ -63,4 +65,3 @@ for tool_class in [
     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"
 

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

@@ -4,6 +4,7 @@ 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):
     """
@@ -15,18 +16,24 @@ class ReadFilesTool(ToolBase):
     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)
+            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))
+                self.report_warning(
+                    tr("❗ not found: {disp_path}", disp_path=disp_path)
+                )
                 results.append(f"--- File: {disp_path} (not found) ---\n")
                 continue
             try:
@@ -35,6 +42,14 @@ class ReadFilesTool(ToolBase):
                 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")
+                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)

janito/tools/adapters/local/run_bash_command.py

@@ -24,6 +24,7 @@ class RunBashCommandTool(ToolBase):
     Returns:
         str: File paths and line counts for stdout and stderr.
     """
+
     permissions = ToolPermissions(execute=True)
     tool_name = "run_bash_command"
 

janito/tools/adapters/local/run_powershell_command.py

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