janito 1.14.3__py3-none-any.whl → 2.0.1__py3-none-any.whl

janito/{agent/tools → tools/adapters/local}/remove_directory.py

@@ -1,14 +1,14 @@
-from janito.agent.tool_base import ToolBase
-from janito.agent.tools_utils.action_type import ActionType
-from janito.agent.tool_registry import register_tool
-from janito.agent.tools_utils.utils import pluralize, display_path
+from janito.tools.tool_base import ToolBase
+from janito.report_events import ReportAction
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.tools.tool_utils import pluralize, display_path
 from janito.i18n import tr
 import shutil
 import os
 import zipfile
 
 
-@register_tool(name="remove_directory")
+@register_local_tool
 class RemoveDirectoryTool(ToolBase):
     """
     Remove a directory.
@@ -22,11 +22,13 @@ class RemoveDirectoryTool(ToolBase):
             - "Error removing directory: <error message>"
     """
 
+    tool_name = "remove_directory"
+
     def run(self, file_path: str, recursive: bool = False) -> str:
         disp_path = display_path(file_path)
-        self.report_info(
-            ActionType.WRITE,
+        self.report_action(
             tr("🗃️ Remove directory '{disp_path}' ...", disp_path=disp_path),
+            ReportAction.CREATE,
         )
         backup_zip = None
         try:
@@ -46,12 +48,16 @@ class RemoveDirectoryTool(ToolBase):
             else:
                 os.rmdir(file_path)
             self.report_success(
-                tr("✅ 1 {dir_word}", dir_word=pluralize("directory", 1))
+                tr("✅ 1 {dir_word}", dir_word=pluralize("directory", 1)),
+                ReportAction.CREATE,
             )
             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))
+            self.report_error(
+                tr(" ❌ Error removing directory: {error}", error=e),
+                ReportAction.REMOVE,
+            )
             return tr("Error removing directory: {error}", error=e)

janito/{agent/tools → tools/adapters/local}/remove_file.py

@@ -1,15 +1,14 @@
 import os
 import shutil
-from janito.agent.tool_registry import register_tool
+from janito.tools.adapters.local.adapter import register_local_tool
 
-# from janito.agent.tools_utils.expand_path import expand_path
-from janito.agent.tools_utils.utils import display_path
-from janito.agent.tool_base import ToolBase
-from janito.agent.tools_utils.action_type import ActionType
+from janito.tools.tool_utils import display_path
+from janito.tools.tool_base import ToolBase
+from janito.report_events import ReportAction
 from janito.i18n import tr
 
 
-@register_tool(name="remove_file")
+@register_local_tool
 class RemoveFileTool(ToolBase):
     """
     Remove a file at the specified path.
@@ -19,32 +18,34 @@ class RemoveFileTool(ToolBase):
         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.
     Returns:
         str: Status message indicating the result. Example:
-            - "✅ Successfully removed the file at ..."
-            - "❗ Cannot remove file: ..."
+            - "			 Successfully removed the file at ..."
+            - "			 Cannot remove file: ..."
     """
 
+    tool_name = "remove_file"
+
     def run(self, file_path: str, backup: bool = False) -> str:
         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_info(
-            ActionType.WRITE,
+        self.report_action(
             tr("🗑️ Remove file '{disp_path}' ...", disp_path=disp_path),
+            ReportAction.CREATE,
         )
         if not os.path.exists(path):
-            self.report_error(tr("❌ File does not exist."))
+            self.report_error(tr("❌ File does not exist."), ReportAction.REMOVE)
             return tr("❌ File does not exist.")
         if not os.path.isfile(path):
-            self.report_error(tr("❌ Path is not a file."))
+            self.report_error(tr("❌ Path is not a file."), ReportAction.REMOVE)
             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"))
+            self.report_success(tr("✅ File removed"), ReportAction.CREATE)
             msg = tr(
                 "✅ Successfully removed the file at '{disp_path}'.",
                 disp_path=disp_path,
@@ -56,5 +57,7 @@ class RemoveFileTool(ToolBase):
                 )
             return msg
         except Exception as e:
-            self.report_error(tr("❌ Error removing file: {error}", error=e))
+            self.report_error(
+                tr("❌ Error removing file: {error}", error=e), ReportAction.REMOVE
+            )
             return tr("❌ Error removing file: {error}", error=e)

janito/{agent/tools → tools/adapters/local}/replace_text_in_file.py

@@ -1,14 +1,13 @@
-from janito.agent.tool_base import ToolBase
-from janito.agent.tools_utils.action_type import ActionType
-from janito.agent.tool_registry import register_tool
+from janito.tools.tool_base import ToolBase
+from janito.report_events import ReportAction
+from janito.tools.adapters.local.adapter import register_local_tool
 from janito.i18n import tr
 import shutil
 import re
+from janito.tools.adapters.local.validate_file_syntax.core import validate_file_syntax
 
-from janito.agent.tools.validate_file_syntax.core import validate_file_syntax
 
-
-@register_tool(name="replace_text_in_file")
+@register_local_tool
 class ReplaceTextInFileTool(ToolBase):
     """
     Replace exact occurrences of a given text in a file.
@@ -30,6 +29,8 @@ class ReplaceTextInFileTool(ToolBase):
             - "Error replacing text: <error message>"
     """
 
+    tool_name = "replace_text_in_file"
+
     def run(
         self,
         file_path: str,
@@ -38,7 +39,7 @@ class ReplaceTextInFileTool(ToolBase):
         replace_all: bool = False,
         backup: bool = False,
     ) -> str:
-        from janito.agent.tools_utils.utils import display_path
+        from janito.tools.tool_utils import display_path
 
         disp_path = display_path(file_path)
         action = "(all)" if replace_all else ""
@@ -53,7 +54,7 @@ class ReplaceTextInFileTool(ToolBase):
             replacement_text,
             file_path,
         )
-        self.report_info(ActionType.WRITE, info_msg)
+        self.report_action(info_msg, ReportAction.CREATE)
         try:
             content = self._read_file_content(file_path)
             match_lines = self._find_match_lines(content, search_text)
@@ -65,13 +66,15 @@ class ReplaceTextInFileTool(ToolBase):
             backup_path = file_path + ".bak"
             if backup and file_changed:
                 self._backup_file(file_path, backup_path)
+            validation_result = ""
             if file_changed:
                 self._write_file_content(file_path, new_content)
+                # Perform syntax validation and append result
+                validation_result = validate_file_syntax(file_path)
             warning, concise_warning = self._handle_warnings(
                 replaced_count, file_changed, occurrences
             )
-            if warning:
-                self.report_warning(warning)
+
             if concise_warning:
                 return concise_warning
             self._report_success(match_lines)
@@ -84,16 +87,11 @@ class ReplaceTextInFileTool(ToolBase):
                 line_delta_str,
                 replace_all,
             )
-            final_msg = self._format_final_msg(
+            return self._format_final_msg(
                 file_path, warning, backup_path, match_info, details
-            )
-            # Perform syntax validation and append result if file was changed
-            if file_changed:
-                validation_result = validate_file_syntax(file_path)
-                final_msg += f"\n{validation_result}"
-            return final_msg
+            ) + (f"\n{validation_result}" if validation_result else "")
         except Exception as e:
-            self.report_error(tr(" ❌ Error"))
+            self.report_error(tr(" ❌ Error"), ReportAction.REPLACE)
             return tr("Error replacing text: {error}", error=e)
 
     def _read_file_content(self, file_path):
@@ -147,12 +145,16 @@ class ReplaceTextInFileTool(ToolBase):
         if replaced_count == 0:
             warning = tr(" [Warning: Search text not found in file]")
         if not file_changed:
-            self.report_warning(tr(" ℹ️ No changes made. [not found]"))
+            self.report_warning(
+                tr(" ℹ️ No changes made. (not found)"), ReportAction.CREATE
+            )
             concise_warning = tr(
                 "No changes made. The search text was not found. Expand your search context with surrounding lines if needed."
             )
         if occurrences > 1 and replaced_count == 0:
-            self.report_warning(tr(" ℹ️ No changes made. [not unique]"))
+            self.report_warning(
+                tr(" ℹ️ No changes made. (not unique)"), ReportAction.CREATE
+            )
             concise_warning = tr(
                 "No changes made. The search text is not unique. Expand your search context with surrounding lines to ensure uniqueness."
             )
@@ -162,9 +164,12 @@ class ReplaceTextInFileTool(ToolBase):
         """Report success with line numbers where replacements occurred."""
         if match_lines:
             lines_str = ", ".join(str(line_no) for line_no in match_lines)
-            self.report_success(tr(" ✅ replaced at {lines_str}", lines_str=lines_str))
+            self.report_success(
+                tr(" ✅ replaced at {lines_str}", lines_str=lines_str),
+                ReportAction.CREATE,
+            )
         else:
-            self.report_success(tr(" ✅ replaced (lines unknown)"))
+            self.report_success(tr(" ✅ replaced (lines unknown)"), ReportAction.CREATE)
 
     def _get_line_delta_str(self, content, new_content):
         """Return a string describing the net line change after replacement."""

janito/tools/adapters/local/run_bash_command.py

@@ -0,0 +1,176 @@
+from janito.tools.tool_base import ToolBase
+from janito.report_events import ReportAction
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.i18n import tr
+import subprocess
+import tempfile
+import sys
+import os
+import threading
+
+
+@register_local_tool
+class RunBashCommandTool(ToolBase):
+    """
+    Execute a non-interactive command using the bash shell and capture live output.
+    This tool explicitly invokes the 'bash' shell (not just the system default shell), so it requires bash to be installed and available in the system PATH. On Windows, this will only work if bash is available (e.g., via WSL, Git Bash, or similar).
+
+    Parameters:
+        command (str): The bash command to execute.
+        timeout (int): Timeout in seconds for the command. Defaults to 60.
+        require_confirmation (bool): If True, require user confirmation before running. Defaults to False.
+        requires_user_input (bool): If True, warns that the command may require user input and might hang. Defaults to False. Non-interactive commands are preferred for automation and reliability.
+
+    Returns:
+        str: File paths and line counts for stdout and stderr.
+    """
+    provides_execution = True
+    tool_name = "run_bash_command"
+
+    def _stream_output(self, stream, file_obj, report_func, count_func, counter):
+        for line in stream:
+            file_obj.write(line)
+            file_obj.flush()
+            report_func(line.rstrip("\r\n"), ReportAction.EXECUTE)
+            if count_func == "stdout":
+                counter["stdout"] += 1
+            else:
+                counter["stderr"] += 1
+
+    def run(
+        self,
+        command: str,
+        timeout: int = 60,
+        require_confirmation: bool = False,
+        requires_user_input: bool = False,
+    ) -> str:
+        if not command.strip():
+            self.report_warning(tr("ℹ️ Empty command provided."), ReportAction.EXECUTE)
+            return tr("Warning: Empty command provided. Operation skipped.")
+        self.report_action(
+            tr("🖥️ Run bash command: {command} ...\n", command=command),
+            ReportAction.EXECUTE,
+        )
+        if requires_user_input:
+            self.report_warning(
+                tr(
+                    "⚠️  Warning: This command might be interactive, require user input, and might hang."
+                ),
+                ReportAction.EXECUTE,
+            )
+            sys.stdout.flush()
+        try:
+            with (
+                tempfile.NamedTemporaryFile(
+                    mode="w+", prefix="run_bash_stdout_", delete=False, encoding="utf-8"
+                ) as stdout_file,
+                tempfile.NamedTemporaryFile(
+                    mode="w+", prefix="run_bash_stderr_", delete=False, encoding="utf-8"
+                ) as stderr_file,
+            ):
+                env = os.environ.copy()
+                env["PYTHONIOENCODING"] = "utf-8"
+                env["LC_ALL"] = "C.UTF-8"
+                env["LANG"] = "C.UTF-8"
+                process = subprocess.Popen(
+                    ["bash", "-c", command],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                    encoding="utf-8",
+                    bufsize=1,
+                    env=env,
+                )
+                counter = {"stdout": 0, "stderr": 0}
+                stdout_thread = threading.Thread(
+                    target=self._stream_output,
+                    args=(
+                        process.stdout,
+                        stdout_file,
+                        self.report_stdout,
+                        "stdout",
+                        counter,
+                    ),
+                )
+                stderr_thread = threading.Thread(
+                    target=self._stream_output,
+                    args=(
+                        process.stderr,
+                        stderr_file,
+                        self.report_stderr,
+                        "stderr",
+                        counter,
+                    ),
+                )
+                stdout_thread.start()
+                stderr_thread.start()
+                try:
+                    return_code = process.wait(timeout=timeout)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    self.report_error(
+                        tr(
+                            " ❌ Timed out after {timeout} seconds.",
+                            timeout=timeout,
+                        ),
+                        ReportAction.EXECUTE,
+                    )
+                    return tr(
+                        "Command timed out after {timeout} seconds.", timeout=timeout
+                    )
+                stdout_thread.join()
+                stderr_thread.join()
+                stdout_file.flush()
+                stderr_file.flush()
+                self.report_success(
+                    tr(
+                        " ✅ return code {return_code}",
+                        return_code=return_code,
+                    ),
+                    ReportAction.EXECUTE,
+                )
+                max_lines = 100
+                # Read back the output for summary
+                stdout_file.seek(0)
+                stderr_file.seek(0)
+                stdout_content = stdout_file.read()
+                stderr_content = stderr_file.read()
+                stdout_lines = counter["stdout"]
+                stderr_lines = counter["stderr"]
+                warning_msg = ""
+                if requires_user_input:
+                    warning_msg = tr(
+                        "⚠️  Warning: This command might be interactive, require user input, and might hang.\n"
+                    )
+                if stdout_lines <= max_lines and stderr_lines <= max_lines:
+                    result = warning_msg + tr(
+                        "Return code: {return_code}\n--- STDOUT ---\n{stdout_content}",
+                        return_code=return_code,
+                        stdout_content=stdout_content,
+                    )
+                    if stderr_content.strip():
+                        result += tr(
+                            "\n--- STDERR ---\n{stderr_content}",
+                            stderr_content=stderr_content,
+                        )
+                    return result
+                else:
+                    result = warning_msg + tr(
+                        "[LARGE OUTPUT]\nstdout_file: {stdout_file} (lines: {stdout_lines})\n",
+                        stdout_file=stdout_file.name,
+                        stdout_lines=stdout_lines,
+                    )
+                    if stderr_lines > 0:
+                        result += tr(
+                            "stderr_file: {stderr_file} (lines: {stderr_lines})\n",
+                            stderr_file=stderr_file.name,
+                            stderr_lines=stderr_lines,
+                        )
+                    result += tr(
+                        "returncode: {return_code}\nUse the view_file tool to inspect the contents of these files when needed.",
+                        return_code=return_code,
+                    )
+                    return result
+        except Exception as e:
+            self.report_error(tr(" ❌ Error: {error}", error=e), ReportAction.EXECUTE)
+            return tr("Error running command: {error}", error=e)

janito/tools/adapters/local/run_powershell_command.py

@@ -0,0 +1,219 @@
+from janito.tools.tool_base import ToolBase
+from janito.report_events import ReportAction
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.i18n import tr
+import subprocess
+import os
+import tempfile
+import threading
+
+
+@register_local_tool
+class RunPowershellCommandTool(ToolBase):
+    """
+    Execute a non-interactive command using the PowerShell shell and capture live output.
+    This tool explicitly invokes 'powershell.exe' (on Windows) or 'pwsh' (on other platforms if available).
+    All commands are automatically prepended with UTF-8 output encoding:
+    $OutputEncoding = [Console]::OutputEncoding = [System.Text.Encoding]::UTF8;
+    For file output, it is recommended to use -Encoding utf8 in your PowerShell commands (e.g., Out-File -Encoding utf8) to ensure correct file encoding.
+
+    Parameters:
+        command (str): The PowerShell command to execute. This string is passed directly to PowerShell using the --Command argument (not as a script file).
+        timeout (int): Timeout in seconds for the command. Defaults to 60.
+        require_confirmation (bool): If True, require user confirmation before running. Defaults to False.
+        requires_user_input (bool): If True, warns that the command may require user input and might hang. Defaults to False. Non-interactive commands are preferred for automation and reliability.
+
+    Returns:
+        str: Output and status message, or file paths/line counts if output is large.
+    """
+    provides_execution = True
+    tool_name = "run_powershell_command"
+
+    def _confirm_and_warn(self, command, require_confirmation, requires_user_input):
+        if requires_user_input:
+            self.report_warning(
+                tr(
+                    "⚠️  Warning: This command might be interactive, require user input, and might hang."
+                ),
+                ReportAction.EXECUTE,
+            )
+        if require_confirmation:
+            confirmed = self.ask_user_confirmation(
+                tr(
+                    "About to run PowerShell command: {command}\nContinue?",
+                    command=command,
+                )
+            )
+            if not confirmed:
+                self.report_warning(
+                    tr("⚠️ Execution cancelled by user."), ReportAction.EXECUTE
+                )
+                return False
+        return True
+
+    def _launch_process(self, shell_exe, command_with_encoding):
+        env = os.environ.copy()
+        env["PYTHONIOENCODING"] = "utf-8"
+        return subprocess.Popen(
+            [
+                shell_exe,
+                "-NoProfile",
+                "-ExecutionPolicy",
+                "Bypass",
+                "-Command",
+                command_with_encoding,
+            ],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            bufsize=1,
+            universal_newlines=True,
+            encoding="utf-8",
+            env=env,
+        )
+
+    def _stream_output(self, stream, file_obj, report_func, count_func, counter):
+        for line in stream:
+            file_obj.write(line)
+            file_obj.flush()
+            report_func(line.rstrip("\r\n"), ReportAction.EXECUTE)
+            if count_func == "stdout":
+                counter["stdout"] += 1
+            else:
+                counter["stderr"] += 1
+
+    def _format_result(
+        self, requires_user_input, return_code, stdout_file, stderr_file, max_lines=100
+    ):
+        warning_msg = ""
+        if requires_user_input:
+            warning_msg = tr(
+                "⚠️  Warning: This command might be interactive, require user input, and might hang.\n"
+            )
+        with open(stdout_file.name, "r", encoding="utf-8", errors="replace") as out_f:
+            stdout_content = out_f.read()
+        with open(stderr_file.name, "r", encoding="utf-8", errors="replace") as err_f:
+            stderr_content = err_f.read()
+        stdout_lines = stdout_content.count("\n")
+        stderr_lines = stderr_content.count("\n")
+        if stdout_lines <= max_lines and stderr_lines <= max_lines:
+            result = warning_msg + tr(
+                "Return code: {return_code}\n--- STDOUT ---\n{stdout_content}",
+                return_code=return_code,
+                stdout_content=stdout_content,
+            )
+            if stderr_content.strip():
+                result += tr(
+                    "\n--- STDERR ---\n{stderr_content}",
+                    stderr_content=stderr_content,
+                )
+            return result
+        else:
+            result = warning_msg + tr(
+                "stdout_file: {stdout_file} (lines: {stdout_lines})\n",
+                stdout_file=stdout_file.name,
+                stdout_lines=stdout_lines,
+            )
+            if stderr_lines > 0 and stderr_content.strip():
+                result += tr(
+                    "stderr_file: {stderr_file} (lines: {stderr_lines})\n",
+                    stderr_file=stderr_file.name,
+                    stderr_lines=stderr_lines,
+                )
+            result += tr(
+                "returncode: {return_code}\nUse the view_file tool to inspect the contents of these files when needed.",
+                return_code=return_code,
+            )
+            return result
+
+    def run(
+        self,
+        command: str,
+        timeout: int = 60,
+        require_confirmation: bool = False,
+        requires_user_input: bool = False,
+    ) -> str:
+        if not command.strip():
+            self.report_warning(tr("ℹ️ Empty command provided."), ReportAction.EXECUTE)
+            return tr("Warning: Empty command provided. Operation skipped.")
+        encoding_prefix = "$OutputEncoding = [Console]::OutputEncoding = [System.Text.Encoding]::UTF8; "
+        command_with_encoding = encoding_prefix + command
+        self.report_action(
+            tr("🖥️ Running PowerShell command: {command} ...\n", command=command),
+            ReportAction.EXECUTE,
+        )
+        if not self._confirm_and_warn(
+            command, require_confirmation, requires_user_input
+        ):
+            return tr("❌ Command execution cancelled by user.")
+        from janito.platform_discovery import PlatformDiscovery
+
+        pd = PlatformDiscovery()
+        shell_exe = "powershell.exe" if pd.is_windows() else "pwsh"
+        try:
+            with (
+                tempfile.NamedTemporaryFile(
+                    mode="w+",
+                    prefix="run_powershell_stdout_",
+                    delete=False,
+                    encoding="utf-8",
+                ) as stdout_file,
+                tempfile.NamedTemporaryFile(
+                    mode="w+",
+                    prefix="run_powershell_stderr_",
+                    delete=False,
+                    encoding="utf-8",
+                ) as stderr_file,
+            ):
+                process = self._launch_process(shell_exe, command_with_encoding)
+                counter = {"stdout": 0, "stderr": 0}
+                stdout_thread = threading.Thread(
+                    target=self._stream_output,
+                    args=(
+                        process.stdout,
+                        stdout_file,
+                        self.report_stdout,
+                        "stdout",
+                        counter,
+                    ),
+                )
+                stderr_thread = threading.Thread(
+                    target=self._stream_output,
+                    args=(
+                        process.stderr,
+                        stderr_file,
+                        self.report_stderr,
+                        "stderr",
+                        counter,
+                    ),
+                )
+                stdout_thread.start()
+                stderr_thread.start()
+                try:
+                    return_code = process.wait(timeout=timeout)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    self.report_error(
+                        tr(
+                            " ❌ Timed out after {timeout} seconds.",
+                            timeout=timeout,
+                        ),
+                        ReportAction.EXECUTE,
+                    )
+                    return tr(
+                        "Command timed out after {timeout} seconds.", timeout=timeout
+                    )
+                stdout_thread.join()
+                stderr_thread.join()
+                stdout_file.flush()
+                stderr_file.flush()
+                self.report_success(
+                    tr(" ✅ return code {return_code}", return_code=return_code),
+                    ReportAction.EXECUTE,
+                )
+                return self._format_result(
+                    requires_user_input, return_code, stdout_file, stderr_file
+                )
+        except Exception as e:
+            self.report_error(tr(" ❌ Error: {error}", error=e), ReportAction.EXECUTE)
+            return tr("Error running command: {error}", error=e)