janito 2.2.0__py3-none-any.whl → 2.3.1__py3-none-any.whl

janito/tools/adapters/local/adapter.py

@@ -3,20 +3,35 @@ from janito.tools.tools_adapter import ToolsAdapterBase as ToolsAdapter
 
 
 class LocalToolsAdapter(ToolsAdapter):
-    def disable_execution_tools(self):
-        """Unregister all tools with provides_execution = True."""
-        to_remove = [name for name, entry in self._tools.items()
-                     if getattr(entry["instance"], "provides_execution", False)]
-        for name in to_remove:
-            self.unregister_tool(name)
+    def set_execution_tools_enabled(self, enabled: bool):
+        """
+        Dynamically include or exclude execution tools from the enabled_tools set.
+        If enabled_tools is None, all tools are enabled (default). If set, restricts enabled tools.
+        """
+        all_tool_names = set(self._tools.keys())
+        exec_tool_names = {
+            name for name, entry in self._tools.items()
+            if getattr(entry["instance"], "provides_execution", False)
+        }
+        if self._enabled_tools is None:
+            # If not restricted, create a new enabled-tools set excluding execution tools if disabling
+            if enabled:
+                self._enabled_tools = None  # all tools enabled
+            else:
+                self._enabled_tools = all_tool_names - exec_tool_names
+        else:
+            if enabled:
+                self._enabled_tools |= exec_tool_names
+            else:
+                self._enabled_tools -= exec_tool_names
 
     """
     Adapter for local, statically registered tools in the agent/tools system.
     Handles registration, lookup, enabling/disabling, listing, and now, tool execution (merged from executor).
     """
 
-    def __init__(self, tools=None, event_bus=None, allowed_tools=None, workdir=None):
-        super().__init__(tools=tools, event_bus=event_bus, allowed_tools=allowed_tools)
+    def __init__(self, tools=None, event_bus=None, enabled_tools=None, workdir=None):
+        super().__init__(tools=tools, event_bus=event_bus, enabled_tools=enabled_tools)
         self._tools: Dict[str, Dict[str, Any]] = {}
         self.workdir = workdir
         if self.workdir:
@@ -56,13 +71,19 @@ class LocalToolsAdapter(ToolsAdapter):
         return self._tools[name]["instance"] if name in self._tools else None
 
     def list_tools(self):
-        return list(self._tools.keys())
+        if self._enabled_tools is None:
+            return list(self._tools.keys())
+        return [name for name in self._tools.keys() if name in self._enabled_tools]
 
     def get_tool_classes(self):
-        return [entry["class"] for entry in self._tools.values()]
+        if self._enabled_tools is None:
+            return [entry["class"] for entry in self._tools.values()]
+        return [entry["class"] for name, entry in self._tools.items() if name in self._enabled_tools]
 
     def get_tools(self):
-        return [entry["instance"] for entry in self._tools.values()]
+        if self._enabled_tools is None:
+            return [entry["instance"] for entry in self._tools.values()]
+        return [entry["instance"] for name, entry in self._tools.items() if name in self._enabled_tools]
 
 
     def add_tool(self, tool):
@@ -94,3 +115,4 @@ def register_local_tool(tool=None):
     if tool is None:
         return decorator
     return decorator(tool)
+

janito/tools/adapters/local/delete_text_in_file.py

@@ -15,7 +15,7 @@ class DeleteTextInFileTool(ToolBase):
         file_path (str): Path to the file to modify.
         start_marker (str): The starting delimiter string.
         end_marker (str): The ending delimiter string.
-        backup (bool, optional): If True, create a backup (.bak) before deleting. Defaults to False.
+
     Returns:
         str: Status message indicating the result.
     """
@@ -52,9 +52,7 @@ class DeleteTextInFileTool(ToolBase):
                     "No blocks found between markers in {file_path}.",
                     file_path=file_path,
                 )
-            backup_path = file_path + ".bak"
-            if backup:
-                self._backup_file(file_path, backup_path)
+
             new_content, deleted_blocks = self._delete_blocks(
                 content, start_marker, end_marker
             )
@@ -62,10 +60,9 @@ class DeleteTextInFileTool(ToolBase):
             validation_result = validate_file_syntax(file_path)
             self._report_success(match_lines)
             return tr(
-                "Deleted {count} block(s) between markers in {file_path}. (backup at {backup_path})",
+                "Deleted {count} block(s) between markers in {file_path}. ",
                 count=deleted_blocks,
-                file_path=file_path,
-                backup_path=backup_path if backup else "N/A",
+                file_path=file_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/move_file.py

@@ -16,7 +16,7 @@ class MoveFileTool(ToolBase):
         src_path (str): Source file or directory path.
         dest_path (str): Destination file or directory path.
         overwrite (bool, optional): Whether to overwrite if the destination exists. Defaults to False.
-        backup (bool, optional): If True, create a backup (.bak for files, .bak.zip for directories) of the destination before moving if it exists. Recommend using backup=True only in the first call to avoid redundant backups. Defaults to False.
+        backup (bool, optional): Deprecated. No backups are created anymore. This flag is ignored. Defaults to False.
     Returns:
         str: Status message indicating the result.
     """
@@ -60,11 +60,7 @@ class MoveFileTool(ToolBase):
             shutil.move(src, dest)
             self.report_success(tr("✅ Move complete."))
             msg = tr("✅ Move complete.")
-            if backup_path:
-                msg += tr(
-                    " (backup at {backup_disp})",
-                    backup_disp=display_path(backup_path),
-                )
+
             return msg
         except Exception as e:
             self.report_error(tr("❌ Error moving: {error}", error=e))
@@ -116,13 +112,7 @@ class MoveFileTool(ToolBase):
                     "❗ Destination '{disp_dest}' already exists and overwrite is False.",
                     disp_dest=disp_dest,
                 )
-            if backup:
-                if os.path.isfile(dest):
-                    backup_path = dest + ".bak"
-                    shutil.copy2(dest, backup_path)
-                elif os.path.isdir(dest):
-                    backup_path = dest.rstrip("/\\") + ".bak.zip"
-                    shutil.make_archive(dest.rstrip("/\\") + ".bak", "zip", dest)
+
             try:
                 if os.path.isfile(dest):
                     os.remove(dest)

janito/tools/adapters/local/remove_directory.py

@@ -28,36 +28,25 @@ class RemoveDirectoryTool(ToolBase):
         disp_path = display_path(file_path)
         self.report_action(
             tr("🗃️ Remove directory '{disp_path}' ...", disp_path=disp_path),
-            ReportAction.CREATE,
+            ReportAction.DELETE,
         )
-        backup_zip = None
+
         try:
             if recursive:
-                # Backup before recursive removal
-                if os.path.exists(file_path) and os.path.isdir(file_path):
-                    backup_zip = file_path.rstrip("/\\") + ".bak.zip"
-                    with zipfile.ZipFile(backup_zip, "w", zipfile.ZIP_DEFLATED) as zipf:
-                        for root, dirs, files in os.walk(file_path):
-                            for file in files:
-                                abs_path = os.path.join(root, file)
-                                rel_path = os.path.relpath(
-                                    abs_path, os.path.dirname(file_path)
-                                )
-                                zipf.write(abs_path, rel_path)
+
                 shutil.rmtree(file_path)
             else:
                 os.rmdir(file_path)
             self.report_success(
                 tr("✅ 1 {dir_word}", dir_word=pluralize("directory", 1)),
-                ReportAction.CREATE,
+                ReportAction.DELETE,
             )
             msg = tr("Directory removed: {disp_path}", disp_path=disp_path)
-            if backup_zip:
-                msg += tr(" (backup at {backup_zip})", backup_zip=backup_zip)
+
             return msg
         except Exception as e:
             self.report_error(
                 tr(" ❌ Error removing directory: {error}", error=e),
-                ReportAction.REMOVE,
+                ReportAction.DELETE,
             )
             return tr("Error removing directory: {error}", error=e)

janito/tools/adapters/local/remove_file.py

@@ -15,7 +15,7 @@ class RemoveFileTool(ToolBase):
 
     Args:
         file_path (str): Path to the file to remove.
-        backup (bool, optional): If True, create a backup (.bak) before removing. Recommend using backup=True only in the first call to avoid redundant backups. Defaults to False.
+        backup (bool, optional): Deprecated. Backups are no longer created. Flag ignored.
     Returns:
         str: Status message indicating the result. Example:
             - "			 Successfully removed the file at ..."
@@ -28,7 +28,7 @@ class RemoveFileTool(ToolBase):
         original_path = file_path
         path = file_path  # Using file_path as is
         disp_path = display_path(original_path)
-        backup_path = None
+
         # Report initial info about what is going to be removed
         self.report_action(
             tr("🗑️ Remove file '{disp_path}' ...", disp_path=disp_path),
@@ -41,20 +41,14 @@ class RemoveFileTool(ToolBase):
             self.report_error(tr("❌ Path is not a file."), ReportAction.DELETE)
             return tr("❌ Path is not a file.")
         try:
-            if backup:
-                backup_path = path + ".bak"
-                shutil.copy2(path, backup_path)
+
             os.remove(path)
             self.report_success(tr("✅ File removed"), ReportAction.DELETE)
             msg = tr(
                 "✅ Successfully removed the file at '{disp_path}'.",
                 disp_path=disp_path,
             )
-            if backup_path:
-                msg += tr(
-                    " (backup at {backup_disp})",
-                    backup_disp=display_path(original_path + ".bak"),
-                )
+
             return msg
         except Exception as e:
             self.report_error(

janito/tools/adapters/local/replace_text_in_file.py

@@ -21,10 +21,10 @@ class ReplaceTextInFileTool(ToolBase):
         search_text (str): The exact text to search for (including indentation).
         replacement_text (str): The text to replace with (including indentation).
         replace_all (bool): If True, replace all occurrences; otherwise, only the first occurrence.
-        backup (bool, optional): If True, create a backup (.bak) before replacing. Recommend using backup=True only in the first call to avoid redundant backups. Defaults to False.
+        backup (bool, optional): Deprecated. No backups are created anymore and this flag is ignored. Defaults to False.
     Returns:
         str: Status message. Example:
-            - "Text replaced in /path/to/file (backup at /path/to/file.bak)"
+            - "Text replaced in /path/to/file"
             - "No changes made. [Warning: Search text not found in file] Please review the original file."
             - "Error replacing text: <error message>"
     """
@@ -63,9 +63,7 @@ class ReplaceTextInFileTool(ToolBase):
                 content, search_text, replacement_text, replace_all, occurrences
             )
             file_changed = new_content != content
-            backup_path = file_path + ".bak"
-            if backup and file_changed:
-                self._backup_file(file_path, backup_path)
+            backup_path = None
             validation_result = ""
             if file_changed:
                 self._write_file_content(file_path, new_content)
@@ -88,7 +86,7 @@ class ReplaceTextInFileTool(ToolBase):
                 replace_all,
             )
             return self._format_final_msg(
-                file_path, warning, backup_path, match_info, details
+                file_path, warning, match_info, details
             ) + (f"\n{validation_result}" if validation_result else "")
         except Exception as e:
             self.report_error(tr(" ❌ Error"), ReportAction.REPLACE)
@@ -260,13 +258,12 @@ class ReplaceTextInFileTool(ToolBase):
             details = ""
         return match_info, details
 
-    def _format_final_msg(self, file_path, warning, backup_path, match_info, details):
+    def _format_final_msg(self, file_path, warning, match_info, details):
         """Format the final status message."""
         return tr(
-            "Text replaced in {file_path}{warning} (backup at {backup_path}). {match_info}{details}",
+            "Text replaced in {file_path}{warning}. {match_info}{details}",
             file_path=file_path,
             warning=warning,
-            backup_path=backup_path,
             match_info=match_info,
             details=details,
         )

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

@@ -24,7 +24,7 @@ def match_line(line, pattern, regex, use_regex, case_sensitive):
     if use_regex:
         return regex and regex.search(line)
     if not case_sensitive:
-        return pattern in line.lower()
+        return pattern.lower() in line.lower()
     return pattern in line
 
 

janito/tools/tools_adapter.py

@@ -13,11 +13,11 @@ class ToolsAdapterBase:
     """
 
     def __init__(
-        self, tools=None, event_bus=None, allowed_tools: Optional[list] = None
+        self, tools=None, event_bus=None, enabled_tools: Optional[list] = None
     ):
         self._tools = tools or []
         self._event_bus = event_bus  # event bus can be set on all adapters
-        self._allowed_tools = set(allowed_tools) if allowed_tools is not None else None
+        self._enabled_tools = set(enabled_tools) if enabled_tools is not None else None
         self.verbose_tools = False
 
     def set_verbose_tools(self, value: bool):
@@ -32,8 +32,10 @@ class ToolsAdapterBase:
         self._event_bus = bus
 
     def get_tools(self):
-        """Return the list of tools managed by this provider."""
-        return self._tools
+        """Return the list of enabled tools managed by this provider."""
+        if self._enabled_tools is None:
+            return self._tools
+        return [tool for tool in self._tools if getattr(tool, 'tool_name', None) in self._enabled_tools]
 
     def add_tool(self, tool):
         self._tools.append(tool)
@@ -84,12 +86,82 @@ class ToolsAdapterBase:
 
         return result
 
+    def _get_tool_callable(self, tool):
+        """Helper to retrieve the primary callable of a tool instance."""
+        if callable(tool):
+            return tool
+        if hasattr(tool, "execute") and callable(getattr(tool, "execute")):
+            return getattr(tool, "execute")
+        if hasattr(tool, "run") and callable(getattr(tool, "run")):
+            return getattr(tool, "run")
+        raise ValueError("Provided tool is not executable.")
+
+    def _validate_arguments_against_signature(self, func, arguments: dict):
+        """Validate provided arguments against a callable signature.
+
+        Returns an error string if validation fails, otherwise ``None``.
+        """
+        import inspect
+
+        if arguments is None:
+            arguments = {}
+        # Ensure the input is a dict to avoid breaking the inspect-based logic
+        if not isinstance(arguments, dict):
+            return "Tool arguments should be provided as an object / mapping"
+
+        sig = inspect.signature(func)
+        params = sig.parameters
+
+        # Check for unexpected arguments (unless **kwargs is accepted)
+        accepts_kwargs = any(
+            p.kind == inspect.Parameter.VAR_KEYWORD for p in params.values()
+        )
+        if not accepts_kwargs:
+            unexpected = [k for k in arguments.keys() if k not in params]
+            if unexpected:
+                return (
+                    "Unexpected argument(s): " + ", ".join(sorted(unexpected))
+                )
+
+        # Check for missing required arguments (ignoring *args / **kwargs / self)
+        required_params = [
+            name
+            for name, p in params.items()
+            if p.kind in (
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                inspect.Parameter.KEYWORD_ONLY,
+            )
+            and p.default is inspect._empty
+            and name != "self"
+        ]
+        missing = [name for name in required_params if name not in arguments]
+        if missing:
+            return "Missing required argument(s): " + ", ".join(sorted(missing))
+
+        return None
+
     def execute_by_name(
         self, tool_name: str, *args, request_id=None, arguments=None, **kwargs
     ):
         self._check_tool_permissions(tool_name, request_id, arguments)
         tool = self.get_tool(tool_name)
         self._ensure_tool_exists(tool, tool_name, request_id, arguments)
+        func = self._get_tool_callable(tool)
+        # First, validate arguments against the callable signature to catch unexpected / missing params
+        sig_error = self._validate_arguments_against_signature(func, arguments)
+        if sig_error:
+            if self._event_bus:
+                self._event_bus.publish(
+                    ToolCallError(
+                        tool_name=tool_name,
+                        request_id=request_id,
+                        error=sig_error,
+                        arguments=arguments,
+                    )
+                )
+            return sig_error
+
+        # Optionally validate against JSON schema if available
         schema = getattr(tool, "schema", None)
         if schema and arguments is not None:
             validation_error = self._validate_arguments_against_schema(
@@ -159,8 +231,8 @@ class ToolsAdapterBase:
         )
 
     def _check_tool_permissions(self, tool_name, request_id, arguments):
-        if self._allowed_tools is not None and tool_name not in self._allowed_tools:
-            error_msg = f"Tool '{tool_name}' is not permitted by adapter allow-list."
+        if self._enabled_tools is not None and tool_name not in self._enabled_tools:
+            error_msg = f"Tool '{tool_name}' is not enabled in this adapter."
             if self._event_bus:
                 self._event_bus.publish(
                     ToolCallError(

janito/version.py

@@ -1,4 +1,4 @@
 # janito/version.py
 """Single source of truth for the janito package version."""
 
-__version__ = "2.2.0"
+__version__ = "2.3.1"