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

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"
 

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

@@ -15,11 +15,11 @@ from janito.tools.adapters.local.adapter import register_local_tool as register_
 @register_tool
 class SearchTextTool(ToolBase):
     """
-    Search for a text pattern (regex or plain string) in all files within one or more directories or file paths and return matching lines or counts. Respects .gitignore.
+    Search for a text query in all files within one or more directories or file paths and return matching lines or counts. Respects .gitignore.
     Args:
         paths (str): String of one or more paths (space-separated) to search in. Each path can be a directory or a file.
-        pattern (str): Regex pattern or plain text substring to search for in files. Must not be empty. Tries regex first, falls back to substring if regex is invalid.
-        is_regex (bool): If True, treat pattern as a regular expression. If False, treat as plain text (default).
+        query (str): Text or regular expression to search for in files. Must not be empty. When use_regex=True, this is treated as a regex pattern; otherwise as plain text.
+        use_regex (bool): If True, treat query as a regular expression. If False, treat as plain text (default).
         case_sensitive (bool): If False, perform a case-insensitive search. Default is True (case sensitive).
         max_depth (int, optional): Maximum directory depth to search. If 0 (default), search is recursive with no depth limit. If >0, limits recursion to that depth. Setting max_depth=1 disables recursion (only top-level directory). Ignored for file paths.
         max_results (int, optional): Maximum number of results to return. Defaults to 100. 0 means no limit.
@@ -29,13 +29,14 @@ class SearchTextTool(ToolBase):
              If count_only is True, returns per-file and total match counts.
         If max_results is reached, appends a note to the output.
     """
+
     permissions = ToolPermissions(read=True)
     tool_name = "search_text"
 
     def _handle_file(
         self,
         search_path,
-        pattern,
+        query,
         regex,
         use_regex,
         case_sensitive,
@@ -46,7 +47,7 @@ class SearchTextTool(ToolBase):
         if count_only:
             match_count, dir_limit_reached, _ = read_file_lines(
                 search_path,
-                pattern,
+                query,
                 regex,
                 use_regex,
                 case_sensitive,
@@ -59,7 +60,7 @@ class SearchTextTool(ToolBase):
         else:
             dir_output, dir_limit_reached, match_count_list = read_file_lines(
                 search_path,
-                pattern,
+                query,
                 regex,
                 use_regex,
                 case_sensitive,
@@ -77,7 +78,7 @@ class SearchTextTool(ToolBase):
     def _handle_path(
         self,
         search_path,
-        pattern,
+        query,
         regex,
         use_regex,
         case_sensitive,
@@ -87,9 +88,9 @@ class SearchTextTool(ToolBase):
         count_only,
     ):
         info_str = tr(
-            "🔍 Search {search_type} '{pattern}' in '{disp_path}'",
+            "🔍 Search {search_type} '{query}' in '{disp_path}'",
             search_type=("regex" if use_regex else "text"),
-            pattern=pattern,
+            query=query,
             disp_path=display_path(search_path),
         )
         if max_depth > 0:
@@ -100,7 +101,7 @@ class SearchTextTool(ToolBase):
         if os.path.isfile(search_path):
             dir_output, dir_limit_reached, per_file_counts = self._handle_file(
                 search_path,
-                pattern,
+                query,
                 regex,
                 use_regex,
                 case_sensitive,
@@ -112,7 +113,7 @@ class SearchTextTool(ToolBase):
             if count_only:
                 per_file_counts, dir_limit_reached, _ = traverse_directory(
                     search_path,
-                    pattern,
+                    query,
                     regex,
                     use_regex,
                     case_sensitive,
@@ -125,7 +126,7 @@ class SearchTextTool(ToolBase):
             else:
                 dir_output, dir_limit_reached, per_file_counts = traverse_directory(
                     search_path,
-                    pattern,
+                    query,
                     regex,
                     use_regex,
                     case_sensitive,
@@ -154,15 +155,15 @@ class SearchTextTool(ToolBase):
     def run(
         self,
         paths: str,
-        pattern: str,
-        is_regex: bool = False,
+        query: str,
+        use_regex: bool = False,
         case_sensitive: bool = False,
         max_depth: int = 0,
         max_results: int = 100,
         count_only: bool = False,
     ) -> str:
         regex, use_regex, error_msg = prepare_pattern(
-            pattern, is_regex, case_sensitive, self.report_error, self.report_warning
+            query, use_regex, case_sensitive, self.report_error, self.report_warning
         )
         if error_msg:
             return error_msg
@@ -173,7 +174,7 @@ class SearchTextTool(ToolBase):
             info_str, dir_output, dir_limit_reached, per_file_counts = (
                 self._handle_path(
                     search_path,
-                    pattern,
+                    query,
                     regex,
                     use_regex,
                     case_sensitive,
@@ -186,7 +187,7 @@ class SearchTextTool(ToolBase):
             if count_only:
                 all_per_file_counts.extend(per_file_counts)
             result_str = format_result(
-                pattern,
+                query,
                 use_regex,
                 dir_output,
                 dir_limit_reached,

janito/tools/adapters/local/search_text/match_lines.py

@@ -20,12 +20,12 @@ def is_binary_file(path, blocksize=1024):
     return False
 
 
-def match_line(line, pattern, regex, use_regex, case_sensitive):
+def match_line(line, query, regex, use_regex, case_sensitive):
     if use_regex:
         return regex and regex.search(line)
     if not case_sensitive:
-        return pattern.lower() in line.lower()
-    return pattern in line
+        return query.lower() in line.lower()
+    return query in line
 
 
 def should_limit(max_results, total_results, match_count, count_only, dir_output):
@@ -37,7 +37,7 @@ def should_limit(max_results, total_results, match_count, count_only, dir_output
 
 def read_file_lines(
     path,
-    pattern,
+    query,
     regex,
     use_regex,
     case_sensitive,
@@ -53,7 +53,7 @@ def read_file_lines(
             open_kwargs = {"mode": "r", "encoding": "utf-8"}
             with open(path, **open_kwargs) as f:
                 for lineno, line in enumerate(f, 1):
-                    if match_line(line, pattern, regex, use_regex, case_sensitive):
+                    if match_line(line, query, regex, use_regex, case_sensitive):
                         match_count += 1
                         if not count_only:
                             dir_output.append(f"{path}:{lineno}: {line.rstrip()}")

janito/tools/adapters/local/search_text/pattern_utils.py

@@ -42,7 +42,7 @@ def prepare_pattern(pattern, is_regex, case_sensitive, report_error, report_warn
 
 
 def format_result(
-    pattern, use_regex, output, limit_reached, count_only=False, per_file_counts=None
+    query, use_regex, output, limit_reached, count_only=False, per_file_counts=None
 ):
     # Ensure output is always a list for joining
     if output is None or not isinstance(output, (list, tuple)):

janito/tools/adapters/local/search_text/traverse_directory.py

@@ -26,7 +26,7 @@ def filter_dirs(dirs, root, gitignore_filter):
 def process_file_count_only(
     path,
     per_file_counts,
-    pattern,
+    query,
     regex,
     use_regex,
     case_sensitive,
@@ -35,7 +35,7 @@ def process_file_count_only(
 ):
     match_count, file_limit_reached, _ = read_file_lines(
         path,
-        pattern,
+        query,
         regex,
         use_regex,
         case_sensitive,
@@ -52,7 +52,7 @@ def process_file_collect(
     path,
     dir_output,
     per_file_counts,
-    pattern,
+    query,
     regex,
     use_regex,
     case_sensitive,
@@ -61,7 +61,7 @@ def process_file_collect(
 ):
     actual_match_count, file_limit_reached, file_lines_output = read_file_lines(
         path,
-        pattern,
+        query,
         regex,
         use_regex,
         case_sensitive,
@@ -86,7 +86,7 @@ def should_limit_depth(root, search_path, max_depth, dirs):
 
 def traverse_directory(
     search_path,
-    pattern,
+    query,
     regex,
     use_regex,
     case_sensitive,
@@ -111,7 +111,7 @@ def traverse_directory(
                 file_limit_reached = process_file_count_only(
                     path,
                     per_file_counts,
-                    pattern,
+                    query,
                     regex,
                     use_regex,
                     case_sensitive,
@@ -126,7 +126,7 @@ def traverse_directory(
                     path,
                     dir_output,
                     per_file_counts,
-                    pattern,
+                    query,
                     regex,
                     use_regex,
                     case_sensitive,

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

@@ -82,6 +82,7 @@ class ValidateFileSyntaxTool(ToolBase):
             - "⚠️ Warning: Syntax error: <error message>"
             - "⚠️ Warning: Unsupported file extension: <ext>"
     """
+
     permissions = ToolPermissions(read=True)
     tool_name = "validate_file_syntax"
 
@@ -96,7 +97,6 @@ class ValidateFileSyntaxTool(ToolBase):
         )
         result = validate_file_syntax(
             path,
-            
             report_warning=self.report_warning,
             report_success=self.report_success,
         )

janito/tools/adapters/local/validate_file_syntax/html_validator.py

@@ -1,6 +1,10 @@
 from janito.i18n import tr
 import re
-from lxml import etree
+
+try:
+    from lxml import etree
+except ImportError:
+    etree = None
 
 
 def validate_html(path: str) -> str:
@@ -48,6 +52,9 @@ def _find_js_outside_script(html_content):
 
 def _parse_html_and_collect_errors(path):
     lxml_error = None
+    if etree is None:
+        lxml_error = tr("⚠️ lxml not installed. Cannot validate HTML.")
+        return lxml_error
     try:
         parser = etree.HTMLParser(recover=False)
         with open(path, "rb") as f:

janito/tools/disabled_tools.py

@@ -0,0 +1,68 @@
+"""Management of disabled tools configuration."""
+
+
+class DisabledToolsState:
+    """Singleton to manage disabled tools configuration."""
+
+    _instance = None
+    _disabled_tools = set()
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    @classmethod
+    def get_disabled_tools(cls):
+        """Get the set of disabled tool names."""
+        return cls._disabled_tools.copy()
+
+    @classmethod
+    def set_disabled_tools(cls, tool_names):
+        """Set the disabled tools from a list or set of tool names."""
+        if isinstance(tool_names, str):
+            tool_names = [
+                name.strip() for name in tool_names.split(",") if name.strip()
+            ]
+        cls._disabled_tools = set(tool_names)
+
+    @classmethod
+    def is_tool_disabled(cls, tool_name):
+        """Check if a specific tool is disabled."""
+        return tool_name in cls._disabled_tools
+
+    @classmethod
+    def disable_tool(cls, tool_name):
+        """Add a tool to the disabled list."""
+        cls._disabled_tools.add(tool_name)
+
+    @classmethod
+    def enable_tool(cls, tool_name):
+        """Remove a tool from the disabled list."""
+        cls._disabled_tools.discard(tool_name)
+
+
+# Convenience functions
+def get_disabled_tools():
+    """Get the current set of disabled tools."""
+    return DisabledToolsState.get_disabled_tools()
+
+
+def set_disabled_tools(tool_names):
+    """Set the disabled tools from a list, set, or comma-separated string."""
+    DisabledToolsState.set_disabled_tools(tool_names)
+
+
+def is_tool_disabled(tool_name):
+    """Check if a specific tool is disabled."""
+    return DisabledToolsState.is_tool_disabled(tool_name)
+
+
+def load_disabled_tools_from_config():
+    """Load disabled tools from global config."""
+    from janito.config import config
+
+    disabled_str = config.get("disabled_tools", "")
+    if disabled_str:
+        DisabledToolsState.set_disabled_tools(disabled_str)
+    return DisabledToolsState.get_disabled_tools()

janito/tools/path_security.py

@@ -20,6 +20,7 @@ Public interface
 Both helpers raise :class:`PathSecurityError` if a path tries to escape the
 workspace.
 """
+
 from __future__ import annotations
 
 import os
@@ -46,7 +47,11 @@ class PathSecurityError(Exception):
 # ---------------------------------------------------------------------------
 
 
-def is_path_within_workdir(path: str, workdir: str | None) -> bool:  # noqa: D401 – we start with an imperative verb  # noqa: D401 – we start with an imperative verb
+def is_path_within_workdir(
+    path: str, workdir: str | None
+) -> (
+    bool
+):  # noqa: D401 – we start with an imperative verb  # noqa: D401 – we start with an imperative verb
     """Return *True* if *path* is located inside *workdir* (or equals it).
 
     Relative *path*s are **resolved relative to the *workdir***, *not* to the
@@ -84,6 +89,7 @@ def is_path_within_workdir(path: str, workdir: str | None) -> bool:  # noqa: D40
 
     # Additionally allow files located inside the system temporary directory.
     import tempfile
+
     abs_tempdir = os.path.abspath(tempfile.gettempdir())
     try:
         common_temp = os.path.commonpath([abs_tempdir, abs_path])
@@ -129,20 +135,18 @@ def _extract_path_keys_from_schema(schema: Mapping[str, Any]) -> set[str]:
     path_keys: set[str] = set()
     if schema is not None:
         for k, v in schema.get("properties", {}).items():
-            if (
-                v.get("format") == "path"
-                or (
-                    v.get("type") == "string"
-                    and (
-                        "path" in v.get("description", "").lower()
-                        or k.endswith("path")
-                        or k == "path"
-                    )
+            if v.get("format") == "path" or (
+                v.get("type") == "string"
+                and (
+                    "path" in v.get("description", "").lower()
+                    or k.endswith("path")
+                    or k == "path"
                 )
             ):
                 path_keys.add(k)
     return path_keys
 
+
 def _validate_argument_value(key: str, value: Any, workdir: str) -> None:
     """Validate a single argument value (string or list of strings) for path security."""
     # Single string argument → validate directly.
@@ -156,6 +160,7 @@ def _validate_argument_value(key: str, value: Any, workdir: str) -> None:
                 if not is_path_within_workdir(item, workdir):
                     _raise_outside_workspace_error(key, item, workdir)
 
+
 def validate_paths_in_arguments(
     arguments: Mapping[str, Any] | None,
     workdir: str | None,
@@ -190,7 +195,9 @@ def validate_paths_in_arguments(
 # ---------------------------------------------------------------------------
 
 
-def _raise_outside_workspace_error(key: str, path: str, workdir: str) -> None:  # noqa: D401
+def _raise_outside_workspace_error(
+    key: str, path: str, workdir: str
+) -> None:  # noqa: D401
     """Raise a consistent :class:`PathSecurityError` for *path*."""
     abs_workdir = os.path.abspath(workdir)
     attempted = (

janito/tools/permissions.py

@@ -1,5 +1,6 @@
 from janito.tools.tool_base import ToolPermissions
 
+
 class AllowedPermissionsState:
     _instance = None
     _permissions = ToolPermissions(read=False, write=False, execute=False)
@@ -30,16 +31,21 @@ class AllowedPermissionsState:
     def get_default_permissions(cls):
         return cls._default_permissions
 
+
 # Convenience functions
 
+
 def get_global_allowed_permissions():
     return AllowedPermissionsState.get_permissions()
 
+
 def set_global_allowed_permissions(permissions):
     AllowedPermissionsState.set_permissions(permissions)
 
+
 def set_default_allowed_permissions(permissions):
     AllowedPermissionsState.set_default_permissions(permissions)
 
+
 def get_default_allowed_permissions():
     return AllowedPermissionsState.get_default_permissions()

janito/tools/permissions_parse.py

@@ -1,12 +1,13 @@
 from janito.tools.tool_base import ToolPermissions
 
+
 def parse_permissions_string(perm_str: str) -> ToolPermissions:
     """
     Parse a string like 'rwx', 'rw', 'r', etc. into a ToolPermissions object.
     """
     perm_str = perm_str.lower()
     return ToolPermissions(
-        read='r' in perm_str,
-        write='w' in perm_str,
-        execute='x' in perm_str,
+        read="r" in perm_str,
+        write="w" in perm_str,
+        execute="x" in perm_str,
     )