janito 1.9.0__py3-none-any.whl → 1.10.0__py3-none-any.whl

janito/agent/tools/get_file_outline/core.py

@@ -1,12 +1,10 @@
 from janito.agent.tool_registry import register_tool
 from .python_outline import parse_python_outline
 from .markdown_outline import parse_markdown_outline
-from janito.agent.tools_utils.formatting import (
-    format_outline_table,
-    format_markdown_outline_table,
-)
+from janito.agent.tools_utils.formatting import OutlineFormatter
 import os
 from janito.agent.tool_base import ToolBase
+from janito.agent.tools_utils.action_type import ActionType
 from janito.agent.tools_utils.utils import display_path, pluralize
 from janito.i18n import tr
 
@@ -23,10 +21,11 @@ class GetFileOutlineTool(ToolBase):
     def run(self, file_path: str) -> str:
         try:
             self.report_info(
+                ActionType.READ,
                 tr(
                     "📄 Outlining file '{disp_path}' ...",
                     disp_path=display_path(file_path),
-                )
+                ),
             )
             ext = os.path.splitext(file_path)[1].lower()
             with open(file_path, "r", encoding="utf-8", errors="replace") as f:
@@ -34,7 +33,7 @@ class GetFileOutlineTool(ToolBase):
             if ext == ".py":
                 outline_items = parse_python_outline(lines)
                 outline_type = "python"
-                table = format_outline_table(outline_items)
+                table = OutlineFormatter.format_outline_table(outline_items)
                 self.report_success(
                     tr(
                         "✅ Outlined {count} {item_word}",
@@ -53,7 +52,7 @@ class GetFileOutlineTool(ToolBase):
             elif ext == ".md":
                 outline_items = parse_markdown_outline(lines)
                 outline_type = "markdown"
-                table = format_markdown_outline_table(outline_items)
+                table = OutlineFormatter.format_markdown_outline_table(outline_items)
                 self.report_success(
                     tr(
                         "✅ Outlined {count} {item_word}",

janito/agent/tools/get_file_outline/search_outline.py

@@ -1,4 +1,5 @@
 from janito.agent.tool_base import ToolBase
+from janito.agent.tools_utils.action_type import ActionType
 from janito.agent.tool_registry import register_tool
 
 
@@ -13,10 +14,11 @@ class SearchOutlineTool(ToolBase):
         from janito.i18n import tr
 
         self.report_info(
+            ActionType.READ,
             tr(
                 "🔍 Searching for outline in '{disp_path}'",
                 disp_path=display_path(file_path),
-            )
+            ),
         )
         # ... rest of implementation ...
         # Example warnings and successes:

janito/agent/tools/get_lines.py

@@ -1,4 +1,5 @@
 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
 from janito.i18n import tr
@@ -30,15 +31,19 @@ class GetLinesTool(ToolBase):
         disp_path = display_path(file_path)
         if from_line and to_line:
             self.report_info(
+                ActionType.READ,
                 tr(
                     "📖 Reading file '{disp_path}' {from_line}-{to_line}",
                     disp_path=disp_path,
                     from_line=from_line,
                     to_line=to_line,
-                )
+                ),
             )
         else:
-            self.report_info(tr("📖 Reading file '{disp_path}'", disp_path=disp_path))
+            self.report_info(
+                ActionType.READ,
+                tr("📖 Reading file '{disp_path}'", disp_path=disp_path),
+            )
         try:
             with open(file_path, "r", encoding="utf-8", errors="replace") as f:
                 lines = f.readlines()

janito/agent/tools/move_file.py

@@ -5,6 +5,7 @@ from janito.agent.tool_registry import register_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.i18n import tr
 
 
@@ -85,11 +86,12 @@ class MoveFileTool(ToolBase):
                 return tr("❌ Error removing destination before move: {error}", error=e)
         try:
             self.report_info(
+                ActionType.WRITE,
                 tr(
                     "📝 Moving from '{disp_src}' to '{disp_dest}' ...",
                     disp_src=disp_src,
                     disp_dest=disp_dest,
-                )
+                ),
             )
             shutil.move(src, dest)
             self.report_success(tr("✅ Move complete."))

janito/agent/tools/present_choices.py

@@ -1,5 +1,6 @@
 from typing import List
 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.i18n import tr
 import questionary
@@ -36,11 +37,12 @@ class PresentChoicesTool(ToolBase):
         if not choices:
             return tr("⚠️ No choices provided.")
         self.report_info(
+            ActionType.EXECUTE,
             tr(
                 "ℹ️ Prompting user: {prompt} (multi_select={multi_select}) ...",
                 prompt=prompt,
                 multi_select=multi_select,
-            )
+            ),
         )
         if multi_select:
             result = questionary.checkbox(

janito/agent/tools/python_command_runner.py

@@ -0,0 +1,150 @@
+import subprocess
+import sys
+import tempfile
+import threading
+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.i18n import tr
+
+
+@register_tool(name="python_command_runner")
+class PythonCommandRunnerTool(ToolBase):
+    """
+    Tool to execute Python code using the `python -c` command-line flag.
+    Args:
+        code (str): The Python code to execute as a string.
+        timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
+    Returns:
+        str: Output and status message, or file paths/line counts if output is large.
+    """
+
+    def run(self, code: str, timeout: int = 60) -> str:
+        if not code.strip():
+            self.report_warning(tr("\u2139\ufe0f Empty code provided."))
+            return tr("Warning: Empty code provided. Operation skipped.")
+        self.report_info(
+            ActionType.EXECUTE, tr("🐍 Running: python -c ...\n{code}\n", code=code)
+        )
+        try:
+            with (
+                tempfile.NamedTemporaryFile(
+                    mode="w+",
+                    prefix="python_cmd_stdout_",
+                    delete=False,
+                    encoding="utf-8",
+                ) as stdout_file,
+                tempfile.NamedTemporaryFile(
+                    mode="w+",
+                    prefix="python_cmd_stderr_",
+                    delete=False,
+                    encoding="utf-8",
+                ) as stderr_file,
+            ):
+                process = subprocess.Popen(
+                    [sys.executable, "-c", code],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                    bufsize=1,
+                    universal_newlines=True,
+                    encoding="utf-8",
+                    env={**dict(), **dict(PYTHONIOENCODING="utf-8")},
+                )
+                stdout_lines = 0
+                stderr_lines = 0
+
+                def stream_output(stream, file_obj, report_func, count_func):
+                    nonlocal stdout_lines, stderr_lines
+                    for line in stream:
+                        file_obj.write(line)
+                        file_obj.flush()
+                        report_func(line)
+                        if count_func == "stdout":
+                            stdout_lines += 1
+                        else:
+                            stderr_lines += 1
+
+                stdout_thread = threading.Thread(
+                    target=stream_output,
+                    args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
+                )
+                stderr_thread = threading.Thread(
+                    target=stream_output,
+                    args=(process.stderr, stderr_file, self.report_stderr, "stderr"),
+                )
+                stdout_thread.start()
+                stderr_thread.start()
+                try:
+                    return_code = process.wait(timeout=timeout)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    self.report_error(
+                        tr("\u274c Timed out after {timeout} seconds.", timeout=timeout)
+                    )
+                    return tr(
+                        "Code timed out after {timeout} seconds.", timeout=timeout
+                    )
+                stdout_thread.join()
+                stderr_thread.join()
+                stdout_file.flush()
+                stderr_file.flush()
+
+                self.report_success(
+                    tr("\u2705 Return code {return_code}", return_code=return_code)
+                )
+                # Read back the content for summary if not too large
+                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()
+                max_lines = 100
+                stdout_lines = stdout_content.count("\n")
+                stderr_lines = stderr_content.count("\n")
+
+                def head_tail(text, n=10):
+                    lines = text.splitlines()
+                    if len(lines) <= 2 * n:
+                        return "\n".join(lines)
+                    return "\n".join(
+                        lines[:n]
+                        + ["... ({} lines omitted) ...".format(len(lines) - 2 * n)]
+                        + lines[-n:]
+                    )
+
+                if stdout_lines <= max_lines and stderr_lines <= max_lines:
+                    result = (
+                        f"Return code: {return_code}\n--- STDOUT ---\n{stdout_content}"
+                    )
+                    if stderr_content.strip():
+                        result += f"\n--- STDERR ---\n{stderr_content}"
+                    return result
+                else:
+                    result = (
+                        f"stdout_file: {stdout_file.name} (lines: {stdout_lines})\n"
+                    )
+                    if stderr_lines > 0 and stderr_content.strip():
+                        result += (
+                            f"stderr_file: {stderr_file.name} (lines: {stderr_lines})\n"
+                        )
+                    result += f"returncode: {return_code}\n"
+                    result += (
+                        "--- STDOUT (head/tail) ---\n"
+                        + head_tail(stdout_content)
+                        + "\n"
+                    )
+                    if stderr_content.strip():
+                        result += (
+                            "--- STDERR (head/tail) ---\n"
+                            + head_tail(stderr_content)
+                            + "\n"
+                        )
+                    result += "Use the get_lines tool to inspect the contents of these files when needed."
+                    return result
+        except Exception as e:
+            self.report_error(tr("\u274c Error: {error}", error=e))
+            return tr("Error running code: {error}", error=e)

janito/agent/tools/python_file_runner.py

@@ -0,0 +1,148 @@
+import subprocess
+import sys
+import tempfile
+import threading
+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.i18n import tr
+
+
+@register_tool(name="python_file_runner")
+class PythonFileRunnerTool(ToolBase):
+    """
+    Tool to execute a specified Python script file.
+    Args:
+        file_path (str): Path to the Python script file to execute.
+        timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
+    Returns:
+        str: Output and status message, or file paths/line counts if output is large.
+    """
+
+    def run(self, file_path: str, timeout: int = 60) -> str:
+        self.report_info(
+            ActionType.EXECUTE,
+            tr("🚀 Running: python {file_path}", file_path=file_path),
+        )
+        try:
+            with (
+                tempfile.NamedTemporaryFile(
+                    mode="w+",
+                    prefix="python_file_stdout_",
+                    delete=False,
+                    encoding="utf-8",
+                ) as stdout_file,
+                tempfile.NamedTemporaryFile(
+                    mode="w+",
+                    prefix="python_file_stderr_",
+                    delete=False,
+                    encoding="utf-8",
+                ) as stderr_file,
+            ):
+                process = subprocess.Popen(
+                    [sys.executable, file_path],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                    bufsize=1,
+                    universal_newlines=True,
+                    encoding="utf-8",
+                    env={**dict(), **dict(PYTHONIOENCODING="utf-8")},
+                )
+                stdout_lines = 0
+                stderr_lines = 0
+
+                def stream_output(stream, file_obj, report_func, count_func):
+                    nonlocal stdout_lines, stderr_lines
+                    for line in stream:
+                        file_obj.write(line)
+                        file_obj.flush()
+                        report_func(line)
+                        if count_func == "stdout":
+                            stdout_lines += 1
+                        else:
+                            stderr_lines += 1
+
+                stdout_thread = threading.Thread(
+                    target=stream_output,
+                    args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
+                )
+                stderr_thread = threading.Thread(
+                    target=stream_output,
+                    args=(process.stderr, stderr_file, self.report_stderr, "stderr"),
+                )
+                stdout_thread.start()
+                stderr_thread.start()
+                try:
+                    return_code = process.wait(timeout=timeout)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    self.report_error(
+                        tr("\u274c Timed out after {timeout} seconds.", timeout=timeout)
+                    )
+                    return tr(
+                        "Code timed out after {timeout} seconds.", timeout=timeout
+                    )
+                stdout_thread.join()
+                stderr_thread.join()
+                stdout_file.flush()
+                stderr_file.flush()
+
+                self.report_success(
+                    tr("\u2705 Return code {return_code}", return_code=return_code)
+                )
+                # Read back the content for summary if not too large
+                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()
+                max_lines = 100
+                stdout_lines = stdout_content.count("\n")
+                stderr_lines = stderr_content.count("\n")
+
+                def head_tail(text, n=10):
+                    lines = text.splitlines()
+                    if len(lines) <= 2 * n:
+                        return "\n".join(lines)
+                    return "\n".join(
+                        lines[:n]
+                        + ["... ({} lines omitted) ...".format(len(lines) - 2 * n)]
+                        + lines[-n:]
+                    )
+
+                if stdout_lines <= max_lines and stderr_lines <= max_lines:
+                    result = (
+                        f"Return code: {return_code}\n--- STDOUT ---\n{stdout_content}"
+                    )
+                    if stderr_content.strip():
+                        result += f"\n--- STDERR ---\n{stderr_content}"
+                    return result
+                else:
+                    result = (
+                        f"stdout_file: {stdout_file.name} (lines: {stdout_lines})\n"
+                    )
+                    if stderr_lines > 0 and stderr_content.strip():
+                        result += (
+                            f"stderr_file: {stderr_file.name} (lines: {stderr_lines})\n"
+                        )
+                    result += f"returncode: {return_code}\n"
+                    result += (
+                        "--- STDOUT (head/tail) ---\n"
+                        + head_tail(stdout_content)
+                        + "\n"
+                    )
+                    if stderr_content.strip():
+                        result += (
+                            "--- STDERR (head/tail) ---\n"
+                            + head_tail(stderr_content)
+                            + "\n"
+                        )
+                    result += "Use the get_lines tool to inspect the contents of these files when needed."
+                    return result
+        except Exception as e:
+            self.report_error(tr("\u274c Error: {error}", error=e))
+            return tr("Error running file: {error}", error=e)

janito/agent/tools/python_stdin_runner.py

@@ -0,0 +1,154 @@
+import subprocess
+import sys
+import tempfile
+import threading
+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.i18n import tr
+
+
+@register_tool(name="python_stdin_runner")
+class PythonStdinRunnerTool(ToolBase):
+    """
+    Tool to execute Python code by passing it to the interpreter via standard input (stdin).
+    Args:
+        code (str): The Python code to execute as a string.
+        timeout (int, optional): Timeout in seconds for the command. Defaults to 60.
+    Returns:
+        str: Output and status message, or file paths/line counts if output is large.
+    """
+
+    def run(self, code: str, timeout: int = 60) -> str:
+        if not code.strip():
+            self.report_warning(tr("\u2139\ufe0f Empty code provided."))
+            return tr("Warning: Empty code provided. Operation skipped.")
+        self.report_info(
+            ActionType.EXECUTE,
+            tr("⚡ Running: python (stdin mode) ...\n{code}\n", code=code),
+        )
+        try:
+            with (
+                tempfile.NamedTemporaryFile(
+                    mode="w+",
+                    prefix="python_stdin_stdout_",
+                    delete=False,
+                    encoding="utf-8",
+                ) as stdout_file,
+                tempfile.NamedTemporaryFile(
+                    mode="w+",
+                    prefix="python_stdin_stderr_",
+                    delete=False,
+                    encoding="utf-8",
+                ) as stderr_file,
+            ):
+                process = subprocess.Popen(
+                    [sys.executable],
+                    stdin=subprocess.PIPE,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                    bufsize=1,
+                    universal_newlines=True,
+                    encoding="utf-8",
+                    env={**dict(), **dict(PYTHONIOENCODING="utf-8")},
+                )
+                stdout_lines = 0
+                stderr_lines = 0
+
+                def stream_output(stream, file_obj, report_func, count_func):
+                    nonlocal stdout_lines, stderr_lines
+                    for line in stream:
+                        file_obj.write(line)
+                        file_obj.flush()
+                        report_func(line)
+                        if count_func == "stdout":
+                            stdout_lines += 1
+                        else:
+                            stderr_lines += 1
+
+                stdout_thread = threading.Thread(
+                    target=stream_output,
+                    args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
+                )
+                stderr_thread = threading.Thread(
+                    target=stream_output,
+                    args=(process.stderr, stderr_file, self.report_stderr, "stderr"),
+                )
+                stdout_thread.start()
+                stderr_thread.start()
+                try:
+                    process.stdin.write(code)
+                    process.stdin.close()
+                    return_code = process.wait(timeout=timeout)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    self.report_error(
+                        tr("\u274c Timed out after {timeout} seconds.", timeout=timeout)
+                    )
+                    return tr(
+                        "Code timed out after {timeout} seconds.", timeout=timeout
+                    )
+                stdout_thread.join()
+                stderr_thread.join()
+                stdout_file.flush()
+                stderr_file.flush()
+
+                self.report_success(
+                    tr("\u2705 Return code {return_code}", return_code=return_code)
+                )
+                # Read back the content for summary if not too large
+                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()
+                max_lines = 100
+                stdout_lines = stdout_content.count("\n")
+                stderr_lines = stderr_content.count("\n")
+
+                def head_tail(text, n=10):
+                    lines = text.splitlines()
+                    if len(lines) <= 2 * n:
+                        return "\n".join(lines)
+                    return "\n".join(
+                        lines[:n]
+                        + ["... ({} lines omitted) ...".format(len(lines) - 2 * n)]
+                        + lines[-n:]
+                    )
+
+                if stdout_lines <= max_lines and stderr_lines <= max_lines:
+                    result = (
+                        f"Return code: {return_code}\n--- STDOUT ---\n{stdout_content}"
+                    )
+                    if stderr_content.strip():
+                        result += f"\n--- STDERR ---\n{stderr_content}"
+                    return result
+                else:
+                    result = (
+                        f"stdout_file: {stdout_file.name} (lines: {stdout_lines})\n"
+                    )
+                    if stderr_lines > 0 and stderr_content.strip():
+                        result += (
+                            f"stderr_file: {stderr_file.name} (lines: {stderr_lines})\n"
+                        )
+                    result += f"returncode: {return_code}\n"
+                    result += (
+                        "--- STDOUT (head/tail) ---\n"
+                        + head_tail(stdout_content)
+                        + "\n"
+                    )
+                    if stderr_content.strip():
+                        result += (
+                            "--- STDERR (head/tail) ---\n"
+                            + head_tail(stderr_content)
+                            + "\n"
+                        )
+                    result += "Use the get_lines tool to inspect the contents of these files when needed."
+                    return result
+        except Exception as e:
+            self.report_error(tr("\u274c Error: {error}", error=e))
+            return tr("Error running code via stdin: {error}", error=e)

janito/agent/tools/remove_directory.py

@@ -1,4 +1,5 @@
 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.i18n import tr
@@ -24,7 +25,8 @@ class RemoveDirectoryTool(ToolBase):
     def run(self, file_path: str, recursive: bool = False) -> str:
         disp_path = display_path(file_path)
         self.report_info(
-            tr("🗃️ Removing directory '{disp_path}' ...", disp_path=disp_path)
+            ActionType.WRITE,
+            tr("🗃️ Removing directory '{disp_path}' ...", disp_path=disp_path),
         )
         backup_zip = None
         try:

janito/agent/tools/remove_file.py

@@ -5,6 +5,7 @@ from janito.agent.tool_registry import register_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.i18n import tr
 
 
@@ -28,7 +29,10 @@ class RemoveFileTool(ToolBase):
         disp_path = display_path(original_path)
         backup_path = None
         # Report initial info about what is going to be removed
-        self.report_info(tr("🗑️ Removing file '{disp_path}' ...", disp_path=disp_path))
+        self.report_info(
+            ActionType.WRITE,
+            tr("🗑️ Removing file '{disp_path}' ...", disp_path=disp_path),
+        )
         if not os.path.exists(path):
             self.report_error(tr("❌ File does not exist."))
             return tr("❌ File does not exist.")

janito/agent/tools/replace_file.py

@@ -3,6 +3,7 @@ import shutil
 from janito.agent.tool_registry import register_tool
 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.i18n import tr
 
 from janito.agent.tools.validate_file_syntax.core import validate_file_syntax
@@ -18,6 +19,8 @@ class ReplaceFileTool(ToolBase):
     Returns:
         str: Status message indicating the result. Example:
             - "✅ Successfully replaced the file at ..."
+
+    Note: Syntax validation is automatically performed after this operation.
     """
 
     def run(self, file_path: str, content: str) -> str:
@@ -34,6 +37,10 @@ class ReplaceFileTool(ToolBase):
         # Check previous operation
         tracker = ToolUseTracker()
         if not tracker.last_operation_is_full_read_or_replace(file_path):
+            self.report_info(
+                ActionType.WRITE,
+                tr("📝 Replacing file '{disp_path}' ...", disp_path=disp_path),
+            )
             self.report_warning(tr("ℹ️ Missing full view."))
             try:
                 with open(file_path, "r", encoding="utf-8", errors="replace") as f:
@@ -41,11 +48,14 @@ class ReplaceFileTool(ToolBase):
             except Exception as e:
                 current_content = f"[Error reading file: {e}]"
             return (
-                "⚠️ [missing full view] You must fully view or replace the file before updating.\n"
+                "⚠️ [missing full view] Update was NOT performed. The full content of the file is included below for your review. Repeat the operation if you wish to proceed.\n"
                 f"--- Current content of {disp_path} ---\n"
                 f"{current_content}"
             )
-        self.report_info(tr("📝 Replacing file '{disp_path}' ...", disp_path=disp_path))
+        self.report_info(
+            ActionType.WRITE,
+            tr("📝 Replacing file '{disp_path}' ...", disp_path=disp_path),
+        )
         backup_path = file_path + ".bak"
         shutil.copy2(file_path, backup_path)
         with open(file_path, "w", encoding="utf-8", errors="replace") as f: