janito 1.12.1__py3-none-any.whl → 1.13.0__py3-none-any.whl

janito/__init__.py

@@ -1 +1 @@
-__version__ = "1.11.0"
+__version__ = "1.13.0"

janito/agent/conversation.py

@@ -93,7 +93,7 @@ class ConversationHandler:
 
     def _handle_no_tool_support(self, messages, max_tokens, spinner):
         print(
-            "\u26a0\ufe0f Endpoint does not support tool use. Proceeding in vanilla mode (tools disabled)."
+            "⚠️ Endpoint does not support tool use. Proceeding in vanilla mode (tools disabled)."
         )
         runtime_config.set("vanilla_mode", True)
         resolved_max_tokens = 8000

janito/agent/tools/find_files.py

@@ -45,7 +45,9 @@ class FindFilesTool(ToolBase):
             dir_output.add(os.path.join(root, d))
         return dir_output
 
-    def run(self, paths: str, pattern: str, max_depth: int = None) -> str:
+    def run(
+        self, paths: str, pattern: str, max_depth: int = None, max_results: int = 0
+    ) -> str:
         if not pattern:
             self.report_warning(tr("ℹ️ Empty file pattern provided."))
             return tr("Warning: Empty file pattern provided. Operation skipped.")
@@ -61,13 +63,15 @@ class FindFilesTool(ToolBase):
             self.report_info(
                 ActionType.READ,
                 tr(
-                    "🔍 Search for files '{pattern}' in '{disp_path}'{depth_msg} ...",
+                    "🔍 Search files '{pattern}' in '{disp_path}'{depth_msg} ...",
                     pattern=pattern,
                     disp_path=disp_path,
                     depth_msg=depth_msg,
                 ),
             )
             dir_output = set()
+            count_scanned = 0
+            limit_reached = False
             for root, dirs, files in walk_dir_with_gitignore(
                 directory, max_depth=max_depth
             ):
@@ -79,11 +83,17 @@ class FindFilesTool(ToolBase):
                         dir_output.update(
                             self._match_dirs_without_slash(root, dirs, pat)
                         )
+                if max_results > 0 and len(dir_output) >= max_results:
+                    limit_reached = True
+                    # Truncate to max_results
+                    dir_output = set(list(dir_output)[:max_results])
+                    break
             self.report_success(
                 tr(
-                    " ✅ {count} {file_word}",
+                    " ✅ {count} {file_word}{max_flag}",
                     count=len(dir_output),
                     file_word=pluralize("file", len(dir_output)),
+                    max_flag=" (max)" if limit_reached else "",
                 )
             )
             if directory.strip() == ".":

janito/agent/tools/get_lines.py

@@ -22,7 +22,7 @@ class GetLinesTool(ToolBase):
             - "---\nFile: /path/to/file.py | Lines: 1-10 (of 100)\n---\n<lines...>"
             - "---\nFile: /path/to/file.py | All lines (total: 100 (all))\n---\n<all lines...>"
             - "Error reading file: <error message>"
-            - "\u2757 not found"
+            - "❗ not found"
     """
 
     def run(self, file_path: str, from_line: int = None, to_line: int = None) -> str:
@@ -83,7 +83,7 @@ class GetLinesTool(ToolBase):
             if at_end:
                 self.report_success(
                     tr(
-                        " \u2705 {selected_len} {line_word} (end)",
+                        " ✅ {selected_len} {line_word} (end)",
                         selected_len=selected_len,
                         line_word=pluralize("line", selected_len),
                     )
@@ -91,7 +91,7 @@ class GetLinesTool(ToolBase):
             elif to_line < total_lines:
                 self.report_success(
                     tr(
-                        " \u2705 {selected_len} {line_word} ({remaining} to end)",
+                        " ✅ {selected_len} {line_word} ({remaining} to end)",
                         selected_len=selected_len,
                         line_word=pluralize("line", selected_len),
                         remaining=total_lines - to_line,
@@ -100,7 +100,7 @@ class GetLinesTool(ToolBase):
         else:
             self.report_success(
                 tr(
-                    " \u2705 {selected_len} {line_word} (all)",
+                    " ✅ {selected_len} {line_word} (all)",
                     selected_len=selected_len,
                     line_word=pluralize("line", selected_len),
                 )
@@ -143,7 +143,7 @@ class GetLinesTool(ToolBase):
     def _handle_read_error(self, e):
         """Handle file read errors and report appropriately."""
         if isinstance(e, FileNotFoundError):
-            self.report_error(tr("\u2757 not found"))
-            return tr("\u2757 not found")
-        self.report_error(tr(" \u274c Error: {error}", error=e))
+            self.report_error(tr("❗ not found"))
+            return tr("❗ not found")
+        self.report_error(tr(" ❌ Error: {error}", error=e))
         return tr("Error reading file: {error}", error=e)

janito/agent/tools/python_command_runner.py

@@ -7,6 +7,7 @@ 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
+from janito.agent.runtime_config import runtime_config
 
 
 @register_tool(name="python_command_runner")
@@ -22,26 +23,13 @@ class PythonCommandRunnerTool(ToolBase):
 
     def run(self, code: str, timeout: int = 60) -> str:
         if not code.strip():
-            self.report_warning(tr("\u2139\ufe0f Empty code provided."))
+            self.report_warning(tr("539 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)
+            ActionType.EXECUTE, tr("40d 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,
-            ):
+            if runtime_config.get("all_out"):
                 process = subprocess.Popen(
                     [sys.executable, "-c", code],
                     stdout=subprocess.PIPE,
@@ -52,24 +40,88 @@ class PythonCommandRunnerTool(ToolBase):
                     encoding="utf-8",
                     env={**os.environ, "PYTHONIOENCODING": "utf-8"},
                 )
-                stdout_lines, stderr_lines = self._stream_process_output(
-                    process, stdout_file, stderr_file
+                stdout_accum = []
+                stderr_accum = []
+
+                def read_stream(stream, report_func, accum):
+                    for line in stream:
+                        accum.append(line)
+                        report_func(line)
+
+                stdout_thread = threading.Thread(
+                    target=read_stream,
+                    args=(process.stdout, self.report_stdout, stdout_accum),
+                )
+                stderr_thread = threading.Thread(
+                    target=read_stream,
+                    args=(process.stderr, self.report_stderr, stderr_accum),
                 )
-                return_code = self._wait_for_process(process, timeout)
-                if return_code is None:
+                stdout_thread.start()
+                stderr_thread.start()
+                try:
+                    return_code = process.wait(timeout=timeout)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    self.report_error(
+                        tr("6d1 Timed out after {timeout} seconds.", timeout=timeout)
+                    )
                     return tr(
                         "Code timed out after {timeout} seconds.", timeout=timeout
                     )
-                stdout_file.flush()
-                stderr_file.flush()
+                stdout_thread.join()
+                stderr_thread.join()
                 self.report_success(
-                    tr("\u2705 Return code {return_code}", return_code=return_code)
-                )
-                return self._format_result(
-                    stdout_file.name, stderr_file.name, return_code
+                    tr("197 Return code {return_code}", return_code=return_code)
                 )
+                stdout = "".join(stdout_accum)
+                stderr = "".join(stderr_accum)
+                result = f"Return code: {return_code}\n--- STDOUT ---\n{stdout}"
+                if stderr and stderr.strip():
+                    result += f"\n--- STDERR ---\n{stderr}"
+                return result
+            else:
+                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={**os.environ, "PYTHONIOENCODING": "utf-8"},
+                    )
+                    stdout_lines, stderr_lines = self._stream_process_output(
+                        process, stdout_file, stderr_file
+                    )
+                    return_code = self._wait_for_process(process, timeout)
+                    if return_code is None:
+                        return tr(
+                            "Code timed out after {timeout} seconds.", timeout=timeout
+                        )
+                    stdout_file.flush()
+                    stderr_file.flush()
+                    self.report_success(
+                        tr("197 Return code {return_code}", return_code=return_code)
+                    )
+                    return self._format_result(
+                        stdout_file.name, stderr_file.name, return_code
+                    )
         except Exception as e:
-            self.report_error(tr("\u274c Error: {error}", error=e))
+            self.report_error(tr("534 Error: {error}", error=e))
             return tr("Error running code: {error}", error=e)
 
     def _stream_process_output(self, process, stdout_file, stderr_file):
@@ -107,7 +159,7 @@ class PythonCommandRunnerTool(ToolBase):
         except subprocess.TimeoutExpired:
             process.kill()
             self.report_error(
-                tr("\u274c Timed out after {timeout} seconds.", timeout=timeout)
+                tr("6d1 Timed out after {timeout} seconds.", timeout=timeout)
             )
             return None
 

janito/agent/tools/python_file_runner.py

@@ -7,6 +7,7 @@ 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
+from janito.agent.runtime_config import runtime_config
 
 
 @register_tool(name="python_file_runner")
@@ -23,23 +24,10 @@ class PythonFileRunnerTool(ToolBase):
     def run(self, file_path: str, timeout: int = 60) -> str:
         self.report_info(
             ActionType.EXECUTE,
-            tr("🚀 Running: python {file_path}", file_path=file_path),
+            tr("680 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,
-            ):
+            if runtime_config.get("all_out"):
                 process = subprocess.Popen(
                     [sys.executable, file_path],
                     stdout=subprocess.PIPE,
@@ -50,24 +38,88 @@ class PythonFileRunnerTool(ToolBase):
                     encoding="utf-8",
                     env={**os.environ, "PYTHONIOENCODING": "utf-8"},
                 )
-                stdout_lines, stderr_lines = self._stream_process_output(
-                    process, stdout_file, stderr_file
+                stdout_accum = []
+                stderr_accum = []
+
+                def read_stream(stream, report_func, accum):
+                    for line in stream:
+                        accum.append(line)
+                        report_func(line)
+
+                stdout_thread = threading.Thread(
+                    target=read_stream,
+                    args=(process.stdout, self.report_stdout, stdout_accum),
+                )
+                stderr_thread = threading.Thread(
+                    target=read_stream,
+                    args=(process.stderr, self.report_stderr, stderr_accum),
                 )
-                return_code = self._wait_for_process(process, timeout)
-                if return_code is None:
+                stdout_thread.start()
+                stderr_thread.start()
+                try:
+                    return_code = process.wait(timeout=timeout)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    self.report_error(
+                        tr("6d1 Timed out after {timeout} seconds.", timeout=timeout)
+                    )
                     return tr(
                         "Code timed out after {timeout} seconds.", timeout=timeout
                     )
-                stdout_file.flush()
-                stderr_file.flush()
+                stdout_thread.join()
+                stderr_thread.join()
                 self.report_success(
-                    tr("\u2705 Return code {return_code}", return_code=return_code)
-                )
-                return self._format_result(
-                    stdout_file.name, stderr_file.name, return_code
+                    tr("197 Return code {return_code}", return_code=return_code)
                 )
+                stdout = "".join(stdout_accum)
+                stderr = "".join(stderr_accum)
+                result = f"Return code: {return_code}\n--- STDOUT ---\n{stdout}"
+                if stderr and stderr.strip():
+                    result += f"\n--- STDERR ---\n{stderr}"
+                return result
+            else:
+                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={**os.environ, "PYTHONIOENCODING": "utf-8"},
+                    )
+                    stdout_lines, stderr_lines = self._stream_process_output(
+                        process, stdout_file, stderr_file
+                    )
+                    return_code = self._wait_for_process(process, timeout)
+                    if return_code is None:
+                        return tr(
+                            "Code timed out after {timeout} seconds.", timeout=timeout
+                        )
+                    stdout_file.flush()
+                    stderr_file.flush()
+                    self.report_success(
+                        tr("197 Return code {return_code}", return_code=return_code)
+                    )
+                    return self._format_result(
+                        stdout_file.name, stderr_file.name, return_code
+                    )
         except Exception as e:
-            self.report_error(tr("\u274c Error: {error}", error=e))
+            self.report_error(tr("534 Error: {error}", error=e))
             return tr("Error running file: {error}", error=e)
 
     def _stream_process_output(self, process, stdout_file, stderr_file):
@@ -105,7 +157,7 @@ class PythonFileRunnerTool(ToolBase):
         except subprocess.TimeoutExpired:
             process.kill()
             self.report_error(
-                tr("\u274c Timed out after {timeout} seconds.", timeout=timeout)
+                tr("6d1 Timed out after {timeout} seconds.", timeout=timeout)
             )
             return None
 

janito/agent/tools/python_stdin_runner.py

@@ -7,6 +7,7 @@ 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
+from janito.agent.runtime_config import runtime_config
 
 
 @register_tool(name="python_stdin_runner")
@@ -22,27 +23,14 @@ class PythonStdinRunnerTool(ToolBase):
 
     def run(self, code: str, timeout: int = 60) -> str:
         if not code.strip():
-            self.report_warning(tr("\u2139\ufe0f Empty code provided."))
+            self.report_warning(tr("ℹ️ 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),
+            tr("5e1 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,
-            ):
+            if runtime_config.get("all_out"):
                 process = subprocess.Popen(
                     [sys.executable],
                     stdin=subprocess.PIPE,
@@ -54,24 +42,91 @@ class PythonStdinRunnerTool(ToolBase):
                     encoding="utf-8",
                     env={**os.environ, "PYTHONIOENCODING": "utf-8"},
                 )
-                stdout_lines, stderr_lines = self._stream_process_output(
-                    process, stdout_file, stderr_file, code
+                stdout_accum = []
+                stderr_accum = []
+
+                def read_stream(stream, report_func, accum):
+                    for line in stream:
+                        accum.append(line)
+                        report_func(line)
+
+                stdout_thread = threading.Thread(
+                    target=read_stream,
+                    args=(process.stdout, self.report_stdout, stdout_accum),
+                )
+                stderr_thread = threading.Thread(
+                    target=read_stream,
+                    args=(process.stderr, self.report_stderr, stderr_accum),
                 )
-                return_code = self._wait_for_process(process, timeout)
-                if return_code is None:
+                stdout_thread.start()
+                stderr_thread.start()
+                process.stdin.write(code)
+                process.stdin.close()
+                try:
+                    return_code = process.wait(timeout=timeout)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    self.report_error(
+                        tr("6d1 Timed out after {timeout} seconds.", timeout=timeout)
+                    )
                     return tr(
                         "Code timed out after {timeout} seconds.", timeout=timeout
                     )
-                stdout_file.flush()
-                stderr_file.flush()
+                stdout_thread.join()
+                stderr_thread.join()
                 self.report_success(
-                    tr("\u2705 Return code {return_code}", return_code=return_code)
-                )
-                return self._format_result(
-                    stdout_file.name, stderr_file.name, return_code
+                    tr("197 Return code {return_code}", return_code=return_code)
                 )
+                stdout = "".join(stdout_accum)
+                stderr = "".join(stderr_accum)
+                result = f"Return code: {return_code}\n--- STDOUT ---\n{stdout}"
+                if stderr and stderr.strip():
+                    result += f"\n--- STDERR ---\n{stderr}"
+                return result
+            else:
+                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={**os.environ, "PYTHONIOENCODING": "utf-8"},
+                    )
+                    stdout_lines, stderr_lines = self._stream_process_output(
+                        process, stdout_file, stderr_file, code
+                    )
+                    return_code = self._wait_for_process(process, timeout)
+                    if return_code is None:
+                        return tr(
+                            "Code timed out after {timeout} seconds.", timeout=timeout
+                        )
+                    stdout_file.flush()
+                    stderr_file.flush()
+                    self.report_success(
+                        tr("197 Return code {return_code}", return_code=return_code)
+                    )
+                    return self._format_result(
+                        stdout_file.name, stderr_file.name, return_code
+                    )
         except Exception as e:
-            self.report_error(tr("\u274c Error: {error}", error=e))
+            self.report_error(tr("534 Error: {error}", error=e))
             return tr("Error running code via stdin: {error}", error=e)
 
     def _stream_process_output(self, process, stdout_file, stderr_file, code):
@@ -111,7 +166,7 @@ class PythonStdinRunnerTool(ToolBase):
         except subprocess.TimeoutExpired:
             process.kill()
             self.report_error(
-                tr("\u274c Timed out after {timeout} seconds.", timeout=timeout)
+                tr("6d1 Timed out after {timeout} seconds.", timeout=timeout)
             )
             return None
 

janito/agent/tools/replace_text_in_file.py

@@ -5,6 +5,8 @@ from janito.i18n import tr
 import shutil
 import re
 
+from janito.agent.tools.validate_file_syntax.core import validate_file_syntax
+
 
 @register_tool(name="replace_text_in_file")
 class ReplaceTextInFileTool(ToolBase):
@@ -82,11 +84,16 @@ class ReplaceTextInFileTool(ToolBase):
                 line_delta_str,
                 replace_all,
             )
-            return self._format_final_msg(
+            final_msg = 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
         except Exception as e:
-            self.report_error(tr(" \u274c Error"))
+            self.report_error(tr(" ❌ Error"))
             return tr("Error replacing text: {error}", error=e)
 
     def _read_file_content(self, file_path):
@@ -140,12 +147,12 @@ class ReplaceTextInFileTool(ToolBase):
         if replaced_count == 0:
             warning = tr(" [Warning: Search text not found in file]")
         if not file_changed:
-            self.report_warning(tr(" \u2139\ufe0f No changes made. [not found]"))
+            self.report_warning(tr(" ℹ️ No changes made. [not found]"))
             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(" \u2139\ufe0f No changes made. [not unique]"))
+            self.report_warning(tr(" ℹ️ No changes made. [not unique]"))
             concise_warning = tr(
                 "No changes made. The search text is not unique. Expand your search context with surrounding lines to ensure uniqueness."
             )
@@ -155,11 +162,9 @@ 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(" \u2705 replaced at {lines_str}", lines_str=lines_str)
-            )
+            self.report_success(tr(" ✅ replaced at {lines_str}", lines_str=lines_str))
         else:
-            self.report_success(tr(" \u2705 replaced (lines unknown)"))
+            self.report_success(tr(" ✅ replaced (lines unknown)"))
 
     def _get_line_delta_str(self, content, new_content):
         """Return a string describing the net line change after replacement."""