janito 3.5.0__tar.gz → 3.5.1__tar.gz

janito-3.5.1/ANNOUNCEMENT_v3.5.1.md

@@ -0,0 +1,50 @@
+# 🚀 Janito v3.5.1 Released - Enhanced Cancellation Support
+
+We're excited to announce the release of **Janito v3.5.1**, a focused patch release that brings comprehensive cancellation support to all system and Python execution tools.
+
+## ✨ Key Features
+
+### 🛑 Real-time Cancellation Support
+- **Cancel long-running bash commands** instantly
+- **Interrupt Python code execution** without hanging processes  
+- **Stop Python file runs** mid-execution with graceful cleanup
+- **Immediate user feedback** when operations are cancelled
+
+### 🎨 Cleaner Terminal Output
+- **Plain text stdout/stderr** for better readability
+- **Improved tool integration** compatibility
+- **Copy-paste friendly** output formatting
+
+## 🔧 Technical Improvements
+
+- **Enhanced process lifecycle management**
+- **Thread-safe cancellation handling**
+- **Proper resource cleanup** on cancellation
+- **Backward compatibility** maintained
+
+## 📦 Installation & Upgrade
+
+```bash
+# New installation
+pip install janito
+
+# Upgrade from v3.5.0
+pip install --upgrade janito
+```
+
+## 📚 Documentation
+
+Updated documentation and examples are available at: https://ikignosis.org/janito/
+
+## 🎯 Use Cases
+
+This release is particularly valuable for:
+- **Long-running data processing** - Cancel operations that are taking too long
+- **Development workflows** - Interrupt builds or tests when needed
+- **Interactive sessions** - Better control over command execution
+- **Resource management** - Prevent hanging processes
+
+---
+
+**Release Date:** August 29, 2025  
+**Full Changelog:** [View on GitHub](https://github.com/ikignosis/janito/releases/tag/v3.5.1)

{janito-3.5.0/janito.egg-info → janito-3.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 3.5.0
+Version: 3.5.1
 Summary: A new Python package called janito.
 Author-email: João Pinto <janito@ikignosis.org>
 Project-URL: Homepage, https://github.com/ikignosis/janito

{janito-3.5.0 → janito-3.5.1}/docs/CHANGELOG.md

@@ -19,6 +19,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Security
 
+## [3.5.1] - 2025-08-29
+
+### Added
+
+- **Cancellation Support**: Added comprehensive cancellation support to system and Python execution tools
+  - **Real-time Cancellation**: Users can now cancel long-running bash commands, Python code execution, and Python file runs
+  - **Graceful Termination**: Clean cancellation handling with proper process cleanup
+  - **User Feedback**: Clear cancellation messages when operations are interrupted
+  - **Thread Safety**: Proper thread cleanup and resource management on cancellation
+
+### Fixed
+
+- **Terminal Output**: Removed styling from stdout/stderr output in rich terminal reporter
+  - **Cleaner Output**: Plain text output for better readability and copy-paste compatibility
+  - **Tool Integration**: Improved compatibility with external tools and scripts
+  - **Consistent Formatting**: Standardized output across all terminal environments
+
+### Technical Improvements
+
+- **Enhanced User Experience**: Cancellation support prevents hanging operations
+- **Code Quality**: Improved error handling and resource cleanup
+- **Process Management**: Better process lifecycle management for external commands
+- **Thread Safety**: Enhanced thread management for concurrent operations
+
 ## [3.5.0] - 2025-08-28
 
 ### Added

janito-3.5.1/docs/changelogs/CHANGELOG_3.5.1.md

@@ -0,0 +1,62 @@
+# Janito v3.5.1 Release Notes
+
+**Release Date: August 29, 2025**
+
+## Overview
+
+Janito v3.5.1 is a patch release focused on improving user experience and reliability. This release adds comprehensive cancellation support to system and Python execution tools, allowing users to interrupt long-running operations gracefully.
+
+## What's New
+
+### 🚀 Cancellation Support
+
+The biggest improvement in v3.5.1 is the addition of real-time cancellation support across all execution tools:
+
+- **Bash Commands**: Cancel long-running shell commands with immediate feedback
+- **Python Code**: Interrupt Python code execution without leaving hanging processes
+- **Python Files**: Stop file execution mid-process with proper cleanup
+- **Graceful Termination**: Clean process shutdown and resource cleanup
+- **User Feedback**: Clear cancellation messages when operations are interrupted
+
+### 🛠️ Terminal Output Improvements
+
+- **Cleaner Output**: Removed styling from stdout/stderr for better readability
+- **Tool Integration**: Improved compatibility with external tools and scripts
+- **Copy-Paste Friendly**: Plain text output for easier copying and pasting
+
+## Technical Details
+
+### Enhanced Process Management
+- Real-time cancellation event handling
+- Proper thread cleanup and resource management
+- Improved error handling for edge cases
+- Better process lifecycle management
+
+### Thread Safety
+- Enhanced thread management for concurrent operations
+- Safe cancellation handling across multiple threads
+- Resource cleanup on cancellation
+
+## Compatibility
+
+This release maintains full backward compatibility with v3.5.0. All existing configurations and workflows continue to work without changes.
+
+## Installation
+
+### New Installation
+```bash
+pip install janito
+```
+
+### Upgrade from v3.5.0
+```bash
+pip install --upgrade janito
+```
+
+## Documentation
+
+Updated documentation is available at: https://ikignosis.org/janito/
+
+## Full Changelog
+
+For a complete list of changes, see: [CHANGELOG.md](../CHANGELOG.md#351---2025-08-29)

{janito-3.5.0 → janito-3.5.1}/janito/plugins/core/system/tools/run_bash_command.py

@@ -30,7 +30,11 @@ class RunBashCommandTool(ToolBase):
     tool_name = "run_bash_command"
 
     def _stream_output(self, stream, file_obj, report_func, count_func, counter):
+        import threading
         for line in stream:
+            # Check for cancellation
+            if hasattr(self, '_cancel_event') and self._cancel_event.is_set():
+                break
             file_obj.write(line)
             file_obj.flush()
             report_func(line.rstrip("\r\n"), ReportAction.EXECUTE)
@@ -87,6 +91,11 @@ class RunBashCommandTool(ToolBase):
                     bufsize=1,
                     env=env,
                 )
+                # Set up cancellation event
+                from janito.llm.cancellation_manager import get_cancellation_manager
+                cancel_manager = get_cancellation_manager()
+                self._cancel_event = cancel_manager.get_current_cancel_event()
+                
                 counter = {"stdout": 0, "stderr": 0}
                 stdout_thread = threading.Thread(
                     target=self._stream_output,
@@ -112,6 +121,14 @@ class RunBashCommandTool(ToolBase):
                 stderr_thread.start()
                 try:
                     return_code = process.wait(timeout=timeout)
+                    # Check if cancelled
+                    if self._cancel_event and self._cancel_event.is_set():
+                        process.kill()
+                        self.report_warning(
+                            tr("Command cancelled by user"),
+                            ReportAction.EXECUTE,
+                        )
+                        return tr("Command cancelled by user")
                 except subprocess.TimeoutExpired:
                     process.kill()
                     self.report_error(
@@ -124,8 +141,12 @@ class RunBashCommandTool(ToolBase):
                     return tr(
                         "Command timed out after {timeout} seconds.", timeout=timeout
                     )
-                stdout_thread.join()
-                stderr_thread.join()
+                finally:
+                    # Ensure threads are stopped
+                    if self._cancel_event:
+                        self._cancel_event.set()
+                    stdout_thread.join(timeout=0.1)
+                    stderr_thread.join(timeout=0.1)
                 stdout_file.flush()
                 stderr_file.flush()
                 if not silent:

{janito-3.5.0 → janito-3.5.1}/janito/plugins/core/system/tools/run_powershell_command.py

@@ -71,6 +71,9 @@ class RunPowershellCommandTool(ToolBase):
 
     def _stream_output(self, stream, file_obj, report_func, count_func, counter):
         for line in stream:
+            # Check for cancellation
+            if hasattr(self, '_cancel_event') and self._cancel_event.is_set():
+                break
             file_obj.write(line)
             file_obj.flush()
             report_func(line.rstrip("\r\n"), ReportAction.EXECUTE)
@@ -163,6 +166,11 @@ class RunPowershellCommandTool(ToolBase):
                     encoding="utf-8",
                 ) as stderr_file,
             ):
+                # Set up cancellation event
+                from janito.llm.cancellation_manager import get_cancellation_manager
+                cancel_manager = get_cancellation_manager()
+                self._cancel_event = cancel_manager.get_current_cancel_event()
+                
                 process = self._launch_process(shell_exe, command_with_encoding)
                 counter = {"stdout": 0, "stderr": 0}
                 stdout_thread = threading.Thread(
@@ -189,6 +197,14 @@ class RunPowershellCommandTool(ToolBase):
                 stderr_thread.start()
                 try:
                     return_code = process.wait(timeout=timeout)
+                    # Check if cancelled
+                    if self._cancel_event and self._cancel_event.is_set():
+                        process.kill()
+                        self.report_warning(
+                            tr("Command cancelled by user"),
+                            ReportAction.EXECUTE,
+                        )
+                        return tr("Command cancelled by user")
                 except subprocess.TimeoutExpired:
                     process.kill()
                     self.report_error(

{janito-3.5.0 → janito-3.5.1}/janito/plugins/tools/python_code_run.py

@@ -93,6 +93,9 @@ class PythonCodeRun(ToolBase):
         def stream_output(stream, file_obj, report_func, count_func):
             nonlocal stdout_lines, stderr_lines
             for line in stream:
+                # Check for cancellation
+                if hasattr(self, '_cancel_event') and self._cancel_event.is_set():
+                    break
                 file_obj.write(line)
                 file_obj.flush()
                 report_func(line.rstrip("\r\n"))
@@ -101,6 +104,11 @@ class PythonCodeRun(ToolBase):
                 else:
                     stderr_lines += 1
 
+        # Set up cancellation event
+        from janito.llm.cancellation_manager import get_cancellation_manager
+        cancel_manager = get_cancellation_manager()
+        self._cancel_event = cancel_manager.get_current_cancel_event()
+        
         stdout_thread = threading.Thread(
             target=stream_output,
             args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
@@ -111,10 +119,18 @@ class PythonCodeRun(ToolBase):
         )
         stdout_thread.start()
         stderr_thread.start()
-        process.stdin.write(code)
-        process.stdin.close()
-        stdout_thread.join()
-        stderr_thread.join()
+        
+        try:
+            process.stdin.write(code)
+            process.stdin.close()
+            stdout_thread.join()
+            stderr_thread.join()
+        except Exception as e:
+            # Handle cancellation or other errors
+            if self._cancel_event and self._cancel_event.is_set():
+                process.kill()
+                self.report_warning(tr("Code execution cancelled by user"), ReportAction.EXECUTE)
+            raise
         return stdout_lines, stderr_lines
 
     def _wait_for_process(self, process, timeout):

{janito-3.5.0 → janito-3.5.1}/janito/plugins/tools/python_command_run.py

@@ -92,6 +92,9 @@ class PythonCommandRun(ToolBase):
         def stream_output(stream, file_obj, report_func, count_func):
             nonlocal stdout_lines, stderr_lines
             for line in stream:
+                # Check for cancellation
+                if hasattr(self, '_cancel_event') and self._cancel_event.is_set():
+                    break
                 file_obj.write(line)
                 file_obj.flush()
                 from janito.tools.tool_base import ReportAction
@@ -102,6 +105,11 @@ class PythonCommandRun(ToolBase):
                 else:
                     stderr_lines += 1
 
+        # Set up cancellation event
+        from janito.llm.cancellation_manager import get_cancellation_manager
+        cancel_manager = get_cancellation_manager()
+        self._cancel_event = cancel_manager.get_current_cancel_event()
+        
         stdout_thread = threading.Thread(
             target=stream_output,
             args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
@@ -112,8 +120,16 @@ class PythonCommandRun(ToolBase):
         )
         stdout_thread.start()
         stderr_thread.start()
-        stdout_thread.join()
-        stderr_thread.join()
+        
+        try:
+            stdout_thread.join()
+            stderr_thread.join()
+        except Exception as e:
+            # Handle cancellation
+            if self._cancel_event and self._cancel_event.is_set():
+                process.kill()
+                self.report_warning(tr("Code execution cancelled by user"), ReportAction.EXECUTE)
+            raise
         return stdout_lines, stderr_lines
 
     def _wait_for_process(self, process, timeout):

{janito-3.5.0 → janito-3.5.1}/janito/plugins/tools/python_file_run.py

@@ -92,6 +92,9 @@ class PythonFileRun(ToolBase):
         def stream_output(stream, file_obj, report_func, count_func):
             nonlocal stdout_lines, stderr_lines
             for line in stream:
+                # Check for cancellation
+                if hasattr(self, '_cancel_event') and self._cancel_event.is_set():
+                    break
                 file_obj.write(line)
                 file_obj.flush()
                 # Always supply a default action for stdout/stderr reporting
@@ -103,6 +106,11 @@ class PythonFileRun(ToolBase):
                 else:
                     stderr_lines += 1
 
+        # Set up cancellation event
+        from janito.llm.cancellation_manager import get_cancellation_manager
+        cancel_manager = get_cancellation_manager()
+        self._cancel_event = cancel_manager.get_current_cancel_event()
+        
         stdout_thread = threading.Thread(
             target=stream_output,
             args=(process.stdout, stdout_file, self.report_stdout, "stdout"),
@@ -113,8 +121,16 @@ class PythonFileRun(ToolBase):
         )
         stdout_thread.start()
         stderr_thread.start()
-        stdout_thread.join()
-        stderr_thread.join()
+        
+        try:
+            stdout_thread.join()
+            stderr_thread.join()
+        except Exception as e:
+            # Handle cancellation
+            if self._cancel_event and self._cancel_event.is_set():
+                process.kill()
+                self.report_warning(tr("File execution cancelled by user"), ReportAction.EXECUTE)
+            raise
         return stdout_lines, stderr_lines
 
     def _wait_for_process(self, process, timeout):

{janito-3.5.0 → janito-3.5.1/janito.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: janito
-Version: 3.5.0
+Version: 3.5.1
 Summary: A new Python package called janito.
 Author-email: João Pinto <janito@ikignosis.org>
 Project-URL: Homepage, https://github.com/ikignosis/janito

{janito-3.5.0 → janito-3.5.1}/janito.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@
 .pre-commit-config.yaml
 .secrets.baseline
 ANNOUNCEMENT_v3.1.0.md
+ANNOUNCEMENT_v3.5.1.md
 LICENSE
 MARKET_ANALYST_README.md
 README-dev.md
@@ -75,6 +76,7 @@ docs/changelogs/CHANGELOG_2.26.0.md
 docs/changelogs/CHANGELOG_2.27.0.md
 docs/changelogs/CHANGELOG_3.1.0.md
 docs/changelogs/CHANGELOG_3.5.0.md
+docs/changelogs/CHANGELOG_3.5.1.md
 docs/changelogs/RELEASE_NOTES_2.22.0.md
 docs/changelogs/RELEASE_NOTES_2.24.1.md
 docs/code_intelligence/agentic-frameworks-comparison.md
@@ -353,9 +355,6 @@ janito/plugins/core/system/tools/run_bash_command.py
 janito/plugins/core/system/tools/run_powershell_command.py
 janito/plugins/dev/__init__.py
 janito/plugins/dev/pythondev/__init__.py
-janito/plugins/dev/pythondev/tools/python_code_run.py
-janito/plugins/dev/pythondev/tools/python_command_run.py
-janito/plugins/dev/pythondev/tools/python_file_run.py
 janito/plugins/dev/visualization/__init__.py
 janito/plugins/dev/visualization/tools/read_chart.py
 janito/plugins/tools/__init__.py

janito-3.5.0/janito/plugins/dev/pythondev/tools/python_code_run.py

@@ -1,172 +0,0 @@
-import subprocess
-import os
-import sys
-import tempfile
-import threading
-from janito.tools.tool_base import ToolBase, ToolPermissions
-from janito.report_events import ReportAction
-from janito.tools.adapters.local.adapter import register_local_tool
-from janito.i18n import tr
-
-
-@register_local_tool
-class PythonCodeRunTool(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): Timeout in seconds for the command. Defaults to 60.
-        silent (bool): If True, suppresses progress and status messages. Defaults to False.
-
-    Returns:
-        str: Output and status message, or file paths/line counts if output is large.
-    """
-
-    permissions = ToolPermissions(execute=True)
-    tool_name = "python_code_run"
-
-    def run(self, code: str, timeout: int = 60, silent: bool = False) -> str:
-        if not code.strip():
-            self.report_warning(tr("ℹ️ Empty code provided."), ReportAction.EXECUTE)
-            return tr("Warning: Empty code provided. Operation skipped.")
-        if not silent:
-            self.report_action(
-                tr("⚡ Running: python (stdin mode) ...\n{code}\n", code=code),
-                ReportAction.EXECUTE,
-            )
-            self.report_stdout("\n")
-        else:
-            self.report_action(tr("⚡ Executing..."), ReportAction.EXECUTE)
-        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={**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()
-                if not silent:
-                    self.report_success(
-                        tr("✅ Return code {return_code}", return_code=return_code),
-                        ReportAction.EXECUTE,
-                    )
-                return self._format_result(
-                    stdout_file.name, stderr_file.name, return_code
-                )
-        except Exception as e:
-            self.report_error(tr("❌ Error: {error}", error=e), ReportAction.EXECUTE)
-            return tr("Error running code via stdin: {error}", error=e)
-
-    def _stream_process_output(self, process, stdout_file, stderr_file, code):
-        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.rstrip("\r\n"))
-                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()
-        process.stdin.write(code)
-        process.stdin.close()
-        stdout_thread.join()
-        stderr_thread.join()
-        return stdout_lines, stderr_lines
-
-    def _wait_for_process(self, process, timeout):
-        try:
-            return process.wait(timeout=timeout)
-        except subprocess.TimeoutExpired:
-            process.kill()
-            self.report_error(
-                tr("❌ Timed out after {timeout} seconds.", timeout=timeout),
-                ReportAction.EXECUTE,
-            )
-            return None
-
-    def _format_result(self, stdout_file_name, stderr_file_name, return_code):
-        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--- python_code_run: STDOUT ---\n{stdout_content}"
-            if stderr_content.strip():
-                result += f"\n--- python_code_run: 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 += (
-                "--- python_code_run: STDOUT (head/tail) ---\n"
-                + head_tail(stdout_content)
-                + "\n"
-            )
-            if stderr_content.strip():
-                result += (
-                    "--- python_code_run: STDERR (head/tail) ---\n"
-                    + head_tail(stderr_content)
-                    + "\n"
-                )
-            result += "Use the view_file tool to inspect the contents of these files when needed."
-            return result