cecli-dev 0.100.10rc1__tar.gz → 0.100.10rc2__tar.gz

{cecli_dev-0.100.10rc1 → cecli_dev-0.100.10rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.100.10rc1
+Version: 0.100.10rc2
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-0.100.10rc1 → cecli_dev-0.100.10rc2}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.100.10rc1'
-__version_tuple__ = version_tuple = (0, 100, 10, 'rc1')
+__version__ = version = '0.100.10rc2'
+__version_tuple__ = version_tuple = (0, 100, 10, 'rc2')
 
-__commit_id__ = commit_id = 'g857cf690f'
+__commit_id__ = commit_id = 'g0bbb611c7'

{cecli_dev-0.100.10rc1 → cecli_dev-0.100.10rc2}/cecli/coders/agent_coder.py

@@ -1666,6 +1666,11 @@ Todo list does not exist. Please update it with the `UpdateTodoList` tool.</cont
                 command_str = command_info.get(command_key, {}).get("command", command_key)
                 output += f"\n[bg: {command_str}]\n{cmd_output}\n"
 
+        # Clean up stale (finished) background commands after reading their output
+        for command_key, info in command_info.items():
+            if not info.get("running", False):
+                BackgroundCommandManager.stop_background_command(command_key)
+
         return output
 
     def get_git_status(self):

{cecli_dev-0.100.10rc1 → cecli_dev-0.100.10rc2}/cecli/helpers/background_commands.py

@@ -5,7 +5,6 @@ Provides a static BackgroundCommandManager class for running shell commands
 in the background and capturing their output for injection into chat streams.
 """
 
-import codecs
 import os
 import platform
 import subprocess
@@ -171,31 +170,86 @@ class BackgroundProcess:
         """Start thread to read process output."""
 
         def reader():
-            try:
-                # Simple approach: read lines when available
-                # This will block on readline(), but that's OK because
-                # we're in a separate thread and the buffer will capture
-                # output as soon as it's available
+            import re
+
+            # Regex to strip ANSI terminal escape sequences
+            _ansi_escape = re.compile(
+                r"\x1b\[[0-9;]*[a-zA-Z]|\x1b[\]^_]|[\x1b\x9b][][()#;?]*"
+                r"(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PRZcf-nqry=><~]"
+            )
 
+            def _strip_ansi(text: str) -> str:
+                return _ansi_escape.sub("", text)
+
+            try:
                 if self.master_fd is not None:
                     while not self._stop_event.is_set():
                         try:
                             data = os.read(self.master_fd, 4096).decode(errors="replace")
                             if not data:
                                 break
-                            self.buffer.append(data)
+                            # Strip ANSI escape sequences from PTY output
+                            self.buffer.append(_strip_ansi(data))
                         except (OSError, EOFError):
                             break
                 else:
-                    # Read stdout
-                    for line in iter(self.process.stdout.readline, ""):
-                        if line:
-                            self.buffer.append(line)
+                    has_stdout_fileno = hasattr(self.process.stdout, "fileno")
+                    if has_stdout_fileno:
+                        os.set_blocking(self.process.stdout.fileno(), False)
+                    while not self._stop_event.is_set():
+                        try:
+                            if has_stdout_fileno:
+                                # Use os.read() instead of readline() to capture
+                                # partial line output (e.g. REPL prompts without newlines)
+                                data = os.read(self.process.stdout.fileno(), 4096).decode(
+                                    errors="replace"
+                                )
+                            else:
+                                # Fallback to readline when fileno() is unavailable
+                                # (e.g. mock objects in tests)
+                                data = self.process.stdout.readline()
+                            if data:
+                                self.buffer.append(data)
+                            else:
+                                # Check if process died
+                                if not self.is_alive():
+                                    if has_stdout_fileno:
+                                        # Read any remaining data
+                                        try:
+                                            remaining = os.read(
+                                                self.process.stdout.fileno(), 4096
+                                            ).decode(errors="replace")
+                                            if remaining:
+                                                self.buffer.append(remaining)
+                                        except (OSError, EOFError):
+                                            pass
+                                    break
+                                import time
+
+                                time.sleep(0.05)
+                        except (OSError, EOFError, ValueError):
+                            if not self.is_alive():
+                                break
+                            import time
+
+                            time.sleep(0.05)
 
-                    # Read stderr
-                    for line in iter(self.process.stderr.readline, ""):
-                        if line:
-                            self.buffer.append(line)
+                    # Also capture stderr (best-effort, non-blocking)
+                    if hasattr(self.process.stderr, "fileno"):
+                        try:
+                            os.set_blocking(self.process.stderr.fileno(), False)
+                            while True:
+                                try:
+                                    err_data = os.read(self.process.stderr.fileno(), 4096).decode(
+                                        errors="replace"
+                                    )
+                                    if not err_data:
+                                        break
+                                    self.buffer.append(err_data)
+                                except (OSError, EOFError):
+                                    break
+                        except Exception:
+                            pass
 
             except Exception as e:
                 self.buffer.append(f"\n[Error reading process output: {str(e)}]\n")
@@ -369,6 +423,7 @@ class BackgroundCommandManager:
         persist: bool = False,
         existing_input_buffer: Optional[InputBuffer] = None,
         use_pty: bool = False,
+        master_fd: Optional[int] = None,
     ) -> str:
         """
         Start a command in background.
@@ -390,9 +445,16 @@ class BackgroundCommandManager:
             buffer = existing_buffer or CircularBuffer(max_size=max_buffer_size)
 
             # Use existing process or start new one
-            master_fd = None
-            if use_pty and HAS_PTY and platform.system() != "Windows":
-                master_fd, slave_fd = pty.openpty()
+            # Use provided master_fd (e.g., from _execute_with_timeout) or default to None
+            final_master_fd = master_fd
+
+            # Only create a new PTY if no external master_fd was provided
+            # (prevents overwriting an externally-created PTY fd)
+            can_use_pty = (
+                use_pty and master_fd is None and HAS_PTY and platform.system() != "Windows"
+            )
+            if can_use_pty:
+                final_master_fd, slave_fd = pty.openpty()
 
                 # Disable echo on the slave PTY
                 attr = termios.tcgetattr(slave_fd)
@@ -415,8 +477,13 @@ class BackgroundCommandManager:
             elif existing_process:
                 process = existing_process
             else:
+                # When PTY was requested but isn't available (e.g. Windows),
+                # wrap with stdbuf -oL to force line-buffered output at the libc level
+                resolved_command = (
+                    cls._wrap_line_buffered(command) if use_pty and not HAS_PTY else command
+                )
                 process = subprocess.Popen(
-                    command,
+                    resolved_command,
                     shell=True,
                     stdout=subprocess.PIPE,
                     stderr=subprocess.PIPE,
@@ -434,7 +501,7 @@ class BackgroundCommandManager:
                 buffer,
                 persist=persist,
                 input_buffer=existing_input_buffer,
-                master_fd=master_fd,
+                master_fd=final_master_fd,
             )
 
             # Generate unique key and store
@@ -519,13 +586,8 @@ class BackgroundCommandManager:
             bg_process = cls._background_commands.get(command_key)
             if not bg_process:
                 return False
-            # Decode escape sequences (like \x1b) if present in the string
-            try:
-                text = codecs.decode(text, "unicode_escape")
-            except Exception:
-                pass
-            bg_process.send_input(text)
-            return True
+        bg_process.send_input(text)
+        return True
 
     @classmethod
     def get_all_command_outputs(cls, clear: bool = False) -> Dict[str, str]:
@@ -625,6 +687,61 @@ class BackgroundCommandManager:
                 }
             return result
 
+    _line_buffered_tool = None
+
+    @staticmethod
+    def _detect_line_buffered_tool() -> str:
+        """
+        Detect the best available tool for forcing line-buffered stdout.
+
+        Checks for `stdbuf` (GNU coreutils, most Linux distros) and falls
+        back to `unbuffer` (expect package, available on many systems).
+        If neither is available, returns None.
+
+        Returns:
+            The tool command (e.g., 'stdbuf -oL' or 'unbuffer'), or None
+        """
+        import shutil
+
+        if shutil.which("stdbuf"):
+            return "stdbuf -oL"
+
+        if shutil.which("unbuffer"):
+            return "unbuffer"
+
+        return None
+
+    @staticmethod
+    def _wrap_line_buffered(command: str) -> str:
+        """
+        Wrap a command to force line-buffered stdout when PTY is unavailable.
+
+        When stdout is connected to a pipe instead of a TTY, most programs
+        (Python, C, Ruby, etc.) use full buffering. The stdbuf command uses
+        LD_PRELOAD to override buffering at the libc level. The unbuffer
+        command (from expect) creates a PTY wrapper.
+
+        The detected tool is cached after first check to avoid repeated
+        subprocess/shell calls.
+
+        Args:
+            command: The shell command string
+
+        Returns:
+            Command wrapped with line-buffering prefix, or the original
+            command if no tool is available
+        """
+        if BackgroundCommandManager._line_buffered_tool is None:
+            BackgroundCommandManager._line_buffered_tool = (
+                BackgroundCommandManager._detect_line_buffered_tool()
+            )
+
+        tool = BackgroundCommandManager._line_buffered_tool
+        if tool:
+            return f"{tool} {command}"
+
+        return command
+
     @staticmethod
     def save_paginated_output(
         output: str,

{cecli_dev-0.100.10rc1 → cecli_dev-0.100.10rc2}/cecli/tools/command.py

@@ -3,6 +3,15 @@ import fnmatch
 import os
 import platform
 
+# PTY support for interactive commands (avoids pipe buffering issues)
+try:
+    import pty
+    import termios
+
+    HAS_PTY = True
+except ImportError:
+    HAS_PTY = False
+
 import xxhash
 
 from cecli.helpers.background_commands import BackgroundCommandManager
@@ -21,15 +30,15 @@ class Tool(BaseTool):
         "type": "function",
         "function": {
             "name": "Command",
-            "description": "Execute a shell command.",
+            "description": "Execute a shell command or interact with background processes.",
             "parameters": {
                 "type": "object",
                 "properties": {
                     "command": {
                         "type": "string",
                         "description": (
-                            "The shell command to execute. To send stdin to an existing background"
-                            " command, use the format 'command_key::{key}'."
+                            "The shell command to execute. "
+                            "Required unless background_key is provided."
                         ),
                     },
                     "background": {
@@ -37,42 +46,44 @@ class Tool(BaseTool):
                         "description": "Run command in background (non-blocking).",
                         "default": False,
                     },
-                    "stop": {
-                        "type": "boolean",
+                    "background_key": {
+                        "type": "string",
                         "description": (
-                            "If true, stop the background command specified in the 'command'"
-                            " parameter (format 'command_key::{key}')."
+                            "Key of an existing background command to interact with. "
+                            "Use with 'action' (stdin/stop)."
                         ),
-                        "default": False,
                     },
-                    "pty": {
-                        "type": "boolean",
+                    "action": {
+                        "type": "string",
+                        "enum": ["stdin", "stop"],
                         "description": (
-                            "Run the command in a pseudo-terminal (PTY). Useful for interactive"
-                            " programs like 'vi' or 'top'."
+                            "Action on a background command. Requires background_key: "
+                            "'stdin' to send input, 'stop' to terminate."
                         ),
-                        "default": False,
                     },
                     "stdin": {
                         "type": "string",
                         "description": (
-                            "Input to send to the command's stdin. Supports escape sequences like"
-                            " \\n, \\r, \\t, and hex escapes like \\x1b."
+                            "Input to send. Use with background=True to send at "
+                            "start time, or with background_key + action='stdin'."
+                        ),
+                    },
+                    "pty": {
+                        "type": "boolean",
+                        "description": (
+                            "Use a pseudo-terminal (PTY). Auto-enabled on Unix for "
+                            "background commands. Useful for interactive programs "
+                            "like 'vi' or 'top'."
                         ),
+                        "default": False,
                     },
                 },
-                "required": ["command"],
+                "required": [],
             },
         },
     }
 
     @staticmethod
-    def _parse_command_key(command):
-        """Extract command key from command string if it follows the pattern."""
-        if command and command.startswith("command_key::"):
-            return command.split("::", 1)[1].strip()
-        return None
-
     @staticmethod
     def _hash_command(command):
         """Compute an xxhash of the full command text for session tracking."""
@@ -83,38 +94,41 @@ class Tool(BaseTool):
 
     @classmethod
     async def execute(
-        cls, coder, command, background=False, stop=None, stdin=None, pty=False, **kwargs
+        cls,
+        coder,
+        command=None,
+        background=False,
+        background_key=None,
+        action=None,
+        stdin=None,
+        pty=False,
+        **kwargs,
     ):
         """
-        Execute a shell command, optionally in background.
-        Commands run with timeout based on agent_config['command_timeout'] (default: 30 seconds).
-        """
-        command_key = cls._parse_command_key(command)
+        Execute a shell command or interact with background processes.
 
-        # Handle stopping background commands
-        if stop:
-            if not command_key:
-                return (
-                    "Error: 'command' in format 'command_key::{key}' is required when 'stop' is"
-                    " true."
-                )
-            return await cls._stop_background_command(coder, command_key)
+        For new commands: provide 'command' (and optionally 'background', 'stdin', 'pty').
+        For background interactions: provide 'background_key' + 'action' (stdin/stop).
 
-        # Handle sending stdin to an existing background command
-        if stdin:
-            if not command_key:
-                return (
-                    "Error: 'command' in format 'command_key::{key}' is required when using"
-                    " 'stdin'."
-                )
+        Commands run with timeout based on agent_config['command_timeout'] (default: 30 seconds).
+        """
+        # Handle interactions with an existing background command
+        if background_key:
+            if action == "stdin":
+                if not stdin:
+                    return "Error: 'stdin' is required when action='stdin'."
+                cls.clear_invocation_cache()
+                success = BackgroundCommandManager.send_command_input(background_key, stdin)
+                if success:
+                    return f"Sent input to background command {background_key}: {stdin}"
+                else:
+                    return f"Error: Background command {background_key} not found or not running."
 
-            cls.clear_invocation_cache()
+            elif action == "stop":
+                return await cls._stop_background_command(coder, background_key)
 
-            success = BackgroundCommandManager.send_command_input(command_key, stdin)
-            if success:
-                return f"Sent input to background command {command_key}: {stdin}"
             else:
-                return f"Error: Background command {command_key} not found or not running."
+                return f"Error: Unknown action '{action}'. " "Use one of: stdin, stop."
 
         if not command:
             return "Error: 'command' must be provided."
@@ -143,7 +157,7 @@ class Tool(BaseTool):
             timeout = coder.agent_config.get("command_timeout", 30)
 
         if background:
-            return await cls._execute_background(coder, command, use_pty=pty)
+            return await cls._execute_background(coder, command, use_pty=pty, stdin=stdin)
         elif timeout > 0:
             return await cls._execute_with_timeout(coder, command, timeout, use_pty=pty)
         else:
@@ -199,12 +213,20 @@ class Tool(BaseTool):
         return confirmed
 
     @classmethod
-    async def _execute_background(cls, coder, command_string, use_pty=False):
+    async def _execute_background(cls, coder, command_string, use_pty=None, stdin=None):
         """
         Execute command in background.
+
+        Args:
+            stdin: Optional text to send to the command's stdin after starting
         """
         coder.io.tool_output(f"⛭ Starting background command: {command_string}", type="tool-result")
 
+        # Default to PTY on Unix platforms for proper line-buffered output
+        # (Python and other programs buffer output aggressively on pipes)
+        if use_pty is None:
+            use_pty = platform.system() != "Windows"
+
         # Use static manager to start background command
         command_key = BackgroundCommandManager.start_background_command(
             command_string,
@@ -214,6 +236,10 @@ class Tool(BaseTool):
             use_pty=use_pty,
         )
 
+        # Send stdin to the background command if provided
+        if stdin:
+            BackgroundCommandManager.send_command_input(command_key, stdin)
+
         return (
             f"Background command started: {command_string}\n"
             f"Command key: {command_key}\n"
@@ -221,13 +247,13 @@ class Tool(BaseTool):
         )
 
     @classmethod
-    async def _execute_with_timeout(cls, coder, command_string, timeout, use_pty=False):
+    async def _execute_with_timeout(cls, coder, command_string, timeout, use_pty=None):
         """
         Execute command with timeout. If timeout elapses, move to background.
 
-        IMPORTANT: We use a different approach to avoid pipe conflicts.
-        Instead of reading pipes directly, we let BackgroundCommandManager
-        handle all pipe reading from the start.
+        When use_pty is True (or auto-defaulted on Unix), a pseudo-terminal
+        is used to avoid the full-buffering issue that occurs when stdout is
+        connected to a pipe instead of a TTY.
         """
         import asyncio
         import subprocess
@@ -239,24 +265,59 @@ class Tool(BaseTool):
             f"⛭ Executing shell command with {timeout}s timeout.", type="tool-result"
         )
 
-        shell = os.environ.get("SHELL", "/bin/sh")
+        # Auto-default to PTY on Unix unless explicitly set otherwise
+        if use_pty is None:
+            use_pty = platform.system() != "Windows"
 
         # Create output buffer
         buffer = CircularBuffer(max_size=4096)
 
-        # Start process with pipes for output capture
-        process = subprocess.Popen(
-            command_string,
-            shell=True,
-            executable=shell if platform.system() != "Windows" else None,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            stdin=subprocess.PIPE,
-            cwd=coder.root,
-            text=True,
-            bufsize=1,
-            universal_newlines=True,
-        )
+        # Decide whether to use PTY
+        master_fd = None
+
+        if use_pty and HAS_PTY and platform.system() != "Windows":
+            master_fd, slave_fd = pty.openpty()
+
+            # Disable echo on the slave PTY
+            attr = termios.tcgetattr(slave_fd)
+            attr[3] = attr[3] & ~termios.ECHO
+            termios.tcsetattr(slave_fd, termios.TCSANOW, attr)
+
+            process = subprocess.Popen(
+                command_string,
+                shell=True,
+                executable=os.environ.get("SHELL", "/bin/sh"),
+                stdout=slave_fd,
+                stderr=slave_fd,
+                stdin=slave_fd,
+                cwd=coder.root,
+                close_fds=True,
+                text=True,
+                bufsize=1,
+                universal_newlines=True,
+            )
+            os.close(slave_fd)
+        else:
+            # Start process with pipes for output capture
+            # When PTY was requested but unavailable, wrap with stdbuf for line-buffered output
+            resolved_cmd = (
+                BackgroundCommandManager._wrap_line_buffered(command_string)
+                if use_pty and not HAS_PTY
+                else command_string
+            )
+            shell = os.environ.get("SHELL", "/bin/sh")
+            process = subprocess.Popen(
+                resolved_cmd,
+                shell=True,
+                executable=shell if platform.system() != "Windows" else None,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                stdin=subprocess.PIPE,
+                cwd=coder.root,
+                text=True,
+                bufsize=1,
+                universal_newlines=True,
+            )
 
         # Immediately register with background manager to handle pipe reading
         command_key = BackgroundCommandManager.start_background_command(
@@ -267,6 +328,7 @@ class Tool(BaseTool):
             existing_process=process,
             existing_buffer=buffer,
             persist=True,
+            master_fd=master_fd,
         )
 
         # Now monitor the process with timeout
@@ -340,7 +402,7 @@ class Tool(BaseTool):
             if elapsed >= timeout:
                 # Timeout elapsed, process continues in background
                 coder.io.tool_output(
-                    f"⏱️ Command exceeded {timeout}s timeout, continuing in background...",
+                    f"\u23f1\ufe0f Command exceeded {timeout}s timeout, continuing in background...",
                     type="tool-result",
                 )
 
@@ -428,6 +490,7 @@ class Tool(BaseTool):
         else:
             return output  # Error message from manager
 
+    @classmethod
     async def _handle_errors(cls, coder, command_string, e):
         """Handle errors during command execution."""
         coder.io.tool_error(f"Error executing shell command: {str(e)}")
@@ -451,7 +514,8 @@ class Tool(BaseTool):
 
         command = params.get("command", "")
         background = params.get("background", False)
-        stop = params.get("stop", False)
+        background_key = params.get("background_key")
+        action = params.get("action")
         stdin = params.get("stdin")
         pty = params.get("pty", False)
 
@@ -461,8 +525,8 @@ class Tool(BaseTool):
         extras = []
         if background:
             extras.append("background=True")
-        if stop:
-            extras.append("stop=True")
+        if action:
+            extras.append(f"action={action}")
         if pty:
             extras.append("pty=True")
 
@@ -473,8 +537,13 @@ class Tool(BaseTool):
             coder.io.tool_output(f"{color_start}Stdin:{color_end}")
             coder.io.tool_output(stdin)
 
-        coder.io.tool_output(f"{color_start}Command:{color_end}")
-        coder.io.tool_output(command)
+        if background_key and action:
+            coder.io.tool_output(f"{color_start}Background Key:{color_end} {background_key}")
+            coder.io.tool_output(f"{color_start}Action:{color_end} {action}")
+        elif command:
+            coder.io.tool_output(f"{color_start}Command:{color_end}")
+            coder.io.tool_output(command)
+
         coder.io.tool_output("")
 
         # Output footer

{cecli_dev-0.100.10rc1 → cecli_dev-0.100.10rc2}/cecli_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.100.10rc1
+Version: 0.100.10rc2
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

cecli_dev-0.100.10rc2/cecli_dev.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.100.10rc2",
+  "distance": 0,
+  "node": "g0bbb611c7e4d46cb8d969f6a418461a5b4c0ec4e",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-06-24"
+}

cecli_dev-0.100.10rc1/cecli_dev.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.100.10rc1",
-  "distance": 0,
-  "node": "g857cf690fb58c87bf75b6525d072cbef246dea21",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-06-23"
-}