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

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,
     )

janito/tools/tool_base.py

@@ -4,8 +4,10 @@ from janito.event_bus.bus import event_bus as default_event_bus
 
 from collections import namedtuple
 
-class ToolPermissions(namedtuple('ToolPermissions', ['read', 'write', 'execute'])):
+
+class ToolPermissions(namedtuple("ToolPermissions", ["read", "write", "execute"])):
     __slots__ = ()
+
     def __new__(cls, read=False, write=False, execute=False):
         return super().__new__(cls, read, write, execute)
 
@@ -18,11 +20,16 @@ class ToolBase:
     Base class for all tools in the janito project.
     Extend this class to implement specific tool functionality.
     """
-    permissions: 'ToolPermissions' = None  # Required: must be set by subclasses
+
+    permissions: "ToolPermissions" = None  # Required: must be set by subclasses
 
     def __init__(self, name=None, event_bus=None):
-        if self.permissions is None or not isinstance(self.permissions, ToolPermissions):
-            raise ValueError(f"Tool '{self.__class__.__name__}' must define a 'permissions' attribute of type ToolPermissions.")
+        if self.permissions is None or not isinstance(
+            self.permissions, ToolPermissions
+        ):
+            raise ValueError(
+                f"Tool '{self.__class__.__name__}' must define a 'permissions' attribute of type ToolPermissions."
+            )
         self.name = name or self.__class__.__name__
         self._event_bus = event_bus or default_event_bus
 
@@ -48,7 +55,6 @@ class ToolBase:
             )
         )
 
-
     def report_error(self, message: str, context: dict = None):
         self._event_bus.publish(
             ReportEvent(

janito/tools/tool_use_tracker.py

@@ -50,10 +50,7 @@ class ToolUseTracker:
         for entry in self._history:
             if entry["tool"] == "view_file":
                 params = entry["params"]
-                if (
-                    "path" in params
-                    and normalize_path(params["path"]) == norm_path
-                ):
+                if "path" in params and normalize_path(params["path"]) == norm_path:
                     # If both from_line and to_line are None, full file was read
                     if (
                         params.get("from_line") is None

janito/tools/tool_utils.py

@@ -20,7 +20,7 @@ def display_path(path):
     Returns:
         str: Display path, as an ANSI hyperlink.
     """
-    
+
     port = 8088
     if os.path.isabs(path):
         cwd = os.path.abspath(os.getcwd())