cecli-dev 1.6.0rc4__tar.gz → 1.6.0rc5__tar.gz

{cecli_dev-1.6.0rc4 → cecli_dev-1.6.0rc5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.6.0rc4
+Version: 1.6.0rc5
 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-1.6.0rc4 → cecli_dev-1.6.0rc5}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.6.0rc4'
-__version_tuple__ = version_tuple = (1, 6, 0, 'rc4')
+__version__ = version = '1.6.0rc5'
+__version_tuple__ = version_tuple = (1, 6, 0, 'rc5')
 
-__commit_id__ = commit_id = 'gf40f954f0'
+__commit_id__ = commit_id = 'gca072134c'

{cecli_dev-1.6.0rc4 → cecli_dev-1.6.0rc5}/cecli/coders/agent_coder.py

@@ -939,7 +939,11 @@ class AgentCoder(Coder):
             lint_coro = self.lint_edited(edited, show_output=False)
             lint_errors, interrupted = await interruptible(lint_coro, self.interrupt_event)
             if interrupted:
-                raise KeyboardInterrupt("Interrupted during linting")
+                # Abort the turn with CancelledError, which the linear run loop
+                # handles by re-prompting for input. KeyboardInterrupt is a
+                # BaseException that would escape the worker's event loop and
+                # leave it unable to accept further prompts.
+                raise asyncio.CancelledError("Interrupted during linting")
 
             has_errors = False
 
@@ -1078,7 +1082,10 @@ class AgentCoder(Coder):
             sleep_coro = asyncio.sleep(command_timeout / 2)
             _res, interrupted = await interruptible(sleep_coro, self.interrupt_event)
             if interrupted:
-                raise KeyboardInterrupt("Interrupted while waiting for background commands")
+                # Use CancelledError (not KeyboardInterrupt) so the interrupt
+                # stays inside the worker loop and re-prompts, matching the
+                # lint interrupt path above.
+                raise asyncio.CancelledError("Interrupted while waiting for background commands")
             return True
 
         # Check for recently finished commands that need reflection

{cecli_dev-1.6.0rc4 → cecli_dev-1.6.0rc5}/cecli/coders/base_coder.py

@@ -1999,7 +1999,13 @@ class Coder(metaclass=UsageMeta):
             if self.commands.is_run_command(inp):
                 self.commands.cmd_running_event.clear()  # Command is running
 
-            return await self.commands.run(inp, coder=self, **run_kwargs)
+            try:
+                return await self.commands.run(inp, coder=self, **run_kwargs)
+            finally:
+                # Dispatch can return early (unknown/ambiguous command) or
+                # raise without ever running a command; the gate must still be
+                # reopened or the input/output loops park forever.
+                self.commands.cmd_running_event.set()
 
         await self.check_for_file_mentions(inp)
         inp = await self.check_for_urls(inp)

{cecli_dev-1.6.0rc4 → cecli_dev-1.6.0rc5}/cecli/helpers/coroutines.py

@@ -9,16 +9,10 @@ logger = logging.getLogger(__name__)
 # Strong reference pool to protect fire-and-forget tasks from garbage collection
 background_tasks: set = set()
 
-
-def _handle_result(task: asyncio.Task) -> None:
-    """Callback to clean up references and capture exceptions safely."""
-    background_tasks.discard(task)
-    try:
-        task.result()
-    except asyncio.CancelledError:
-        pass
-    except Exception as e:
-        logger.error(f"Background task failed: {e}", exc_info=True)
+# Grace period granted to a cancelled task to unwind. Transports that defer or
+# swallow cancellation (AnyIO cancel scopes, shielded streams) would otherwise
+# block the interrupting coroutine forever.
+INTERRUPT_UNWIND_GRACE_SECONDS = 5.0
 
 
 def fire_and_forget(coro) -> asyncio.Task:
@@ -35,6 +29,7 @@ async def interruptible_async_generator(async_generator, interrupt_event):
     """
     gen = async_generator.__aiter__()
     interrupt_task = asyncio.create_task(interrupt_event.wait())
+    next_task = None
 
     try:
         while True:
@@ -44,11 +39,7 @@ async def interruptible_async_generator(async_generator, interrupt_event):
             )
 
             if interrupt_task in done:
-                next_task.cancel()
-                try:
-                    await next_task
-                except asyncio.CancelledError:
-                    pass
+                await cancel_and_abandon([next_task])
                 break
 
             if next_task in done:
@@ -57,11 +48,9 @@ async def interruptible_async_generator(async_generator, interrupt_event):
                 except StopAsyncIteration:
                     break
     finally:
-        interrupt_task.cancel()
-        try:
-            await interrupt_task
-        except asyncio.CancelledError:
-            pass
+        # Cancel whichever task is still pending if the generator is closed early
+        # (e.g. GeneratorExit at the wait or yield), not just the interrupt waiter.
+        await cancel_and_abandon([task for task in (next_task, interrupt_task) if task is not None])
 
 
 def is_active(task):
@@ -83,6 +72,10 @@ async def interruptible(coroutine, interrupt_event):
         A tuple of (result, interrupted).
         - If not interrupted: (coroutine_result, False)
         - If interrupted: (None, True)
+
+    A task that ignores cancellation is abandoned once the grace period
+    elapses (see cancel_and_abandon) so a wedged transport cannot block the
+    caller forever.
     """
     if interrupt_event is None:
         interrupt_event = ThreadSafeEvent()
@@ -90,25 +83,26 @@ async def interruptible(coroutine, interrupt_event):
     main_task = asyncio.create_task(coroutine)
     interrupt_task = asyncio.create_task(interrupt_event.wait())
 
-    done, pending = await asyncio.wait(
-        {main_task, interrupt_task},
-        return_when=asyncio.FIRST_COMPLETED,
-    )
+    try:
+        done, pending = await asyncio.wait(
+            {main_task, interrupt_task},
+            return_when=asyncio.FIRST_COMPLETED,
+        )
 
-    for task in pending:
-        task.cancel()
-        try:
-            await task
-        except asyncio.CancelledError:
-            pass  # Expected
+        await cancel_and_abandon(pending)
 
-    if interrupt_task in done:
-        return None, True
+        if interrupt_task in done:
+            return None, True
 
-    try:
-        return main_task.result(), False
-    except asyncio.CancelledError:
-        return None, True
+        try:
+            return main_task.result(), False
+        except asyncio.CancelledError:
+            return None, True
+    finally:
+        # When the caller is cancelled while waiting, neither branch above
+        # runs, so cancel any remaining tasks here instead of orphaning the
+        # inner coroutine (which would keep running detached).
+        await cancel_and_abandon([main_task, interrupt_task])
 
 
 def task_is_cancelling() -> bool:
@@ -133,3 +127,58 @@ def task_is_cancelling() -> bool:
 
     # Python 3.10 fallback: best-effort only (see docstring).
     return bool(getattr(task, "_must_cancel", False))
+
+
+def drain_task_results(tasks):
+    """Consume exceptions from finished tasks so they aren't reported as unretrieved."""
+    for task in tasks:
+        if task.cancelled():
+            continue
+
+        try:
+            exc = task.exception()
+        except (asyncio.CancelledError, asyncio.InvalidStateError):
+            continue
+
+        if exc is not None:
+            logger.warning(f"Task raised while unwinding after interrupt: {exc}")
+
+
+async def cancel_and_abandon(tasks, grace=INTERRUPT_UNWIND_GRACE_SECONDS):
+    """Cancel tasks and wait up to ``grace`` seconds for them to unwind.
+
+    Cancellation is cooperative, and some transports (AnyIO cancel scopes,
+    shielded streams) defer or swallow it. Waiting on them unconditionally
+    would block the caller forever, so anything still running after the grace
+    period is abandoned: it keeps a strong reference so it can finish on its
+    own without tripping the "Task was destroyed but it is pending" warning.
+    """
+    pending_tasks = [task for task in tasks if not task.done()]
+
+    if not pending_tasks:
+        return
+
+    for task in pending_tasks:
+        task.cancel()
+
+    done, still_running = await asyncio.wait(set(pending_tasks), timeout=grace)
+    drain_task_results(done)
+
+    for task in still_running:
+        logger.warning(
+            f"Task ignored cancellation after {grace}s; abandoning it. It may still be"
+            " running and could touch shared state later."
+        )
+        background_tasks.add(task)
+        task.add_done_callback(_handle_result)
+
+
+def _handle_result(task: asyncio.Task) -> None:
+    """Callback to clean up references and capture exceptions safely."""
+    background_tasks.discard(task)
+    try:
+        task.result()
+    except asyncio.CancelledError:
+        pass
+    except Exception as e:
+        logger.error(f"Background task failed: {e}", exc_info=True)

cecli_dev-1.6.0rc5/cecli/helpers/lock_detect.py

@@ -0,0 +1,137 @@
+import asyncio
+import logging
+import os
+import sys
+import threading
+import time
+import traceback
+
+from cecli.decoding import safe_open
+
+# Set up logging to catch asyncio framework logs
+logging.basicConfig(level=logging.INFO)
+logging.getLogger("asyncio").setLevel(logging.DEBUG)
+
+
+# Registered event loops whose asyncio tasks are included in each dump.
+# Task state is only read from the owning loop (see _dump_async_state), since
+# thread stacks alone cannot show coroutine/task state.
+_async_loops: dict = {}
+_async_state_providers: dict = {}
+
+
+def dump_stacks_to_file(filename=".cecli/logs/threads.log", interval=5, max_prints=10):
+    """Periodically writes stack traces to a file, resetting it after max_prints."""
+    print_count = 0
+
+    log_dir = os.path.dirname(filename)
+    if log_dir:
+        os.makedirs(log_dir, exist_ok=True)
+
+    while True:
+        time.sleep(interval)
+        try:
+            # Determine mode: "w" to overwrite/clear on the 11th print, "a" to append
+            mode = "w" if print_count >= max_prints else "a"
+
+            with safe_open(filename, mode) as f:
+                if mode == "w":
+                    f.write(f"--- Log reset automatically after {max_prints} prints ---\n")
+                    print_count = 0  # Reset the counter
+
+                timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+                f.write(
+                    f"\n=================== STACK TRACE DUMP ({timestamp}) ===================\n"
+                )
+
+                for thread_id, frame in sys._current_frames().items():
+                    thread_obj = threading._active.get(thread_id)
+                    thread_name = thread_obj.name if thread_obj else "Unknown Thread"
+
+                    f.write(f"\nThread Name: {thread_name} (ID: {thread_id})\n")
+                    f.write("-" * 40 + "\n")
+                    traceback.print_stack(frame, file=f)
+
+                f.write("=" * 70 + "\n")
+
+            for name in list(_async_loops.keys()):
+                _schedule_async_dump(name, filename)
+
+            print_count += 1  # Increment after a successful write
+
+        except Exception as e:
+            print(f"Error writing stack dump to file: {e}", file=sys.stderr)
+
+
+def register_async_loop(name, loop) -> None:
+    """Register an event loop to include asyncio task dumps for."""
+    _async_loops[name] = loop
+
+
+def register_async_state_provider(name, provider) -> None:
+    """Register a callable returning extra state text for a loop's dump."""
+    _async_state_providers[name] = provider
+
+
+def _format_async_tasks(loop, name) -> str:
+    """Return a readable dump of every task on ``loop`` (loop thread only)."""
+    lines = [f"\n------------------- ASYNCIO TASKS ({name}) -------------------\n"]
+
+    try:
+        tasks = asyncio.all_tasks(loop)
+    except Exception as e:
+        return f"<unable to read asyncio tasks: {e}>\n"
+
+    for task in tasks:
+        lines.append(f"\n[{task.get_name()}] done={task.done()} cancelled={task.cancelled()}\n")
+        lines.append(f"  {task.get_coro()!r}\n")
+
+        for frame in task.get_stack(limit=10):
+            lines.append("".join(traceback.format_stack(frame, limit=1)))
+
+    return "".join(lines)
+
+
+def _dump_async_state(name, filename) -> None:
+    """Append asyncio task/state info for one loop. Runs on the loop thread."""
+    loop = _async_loops.get(name)
+    if loop is None or loop.is_closed():
+        return
+
+    parts = []
+    provider = _async_state_providers.get(name)
+
+    if provider is not None:
+        try:
+            parts.append(provider())
+        except Exception as e:
+            parts.append(f"<state provider error: {e}>\n")
+
+    parts.append(_format_async_tasks(loop, name))
+
+    try:
+        with safe_open(filename, "a") as f:
+            f.write("".join(parts))
+    except Exception:
+        pass
+
+
+def _schedule_async_dump(name, filename) -> None:
+    """Schedule an async-state dump onto a registered loop, if it is running."""
+    loop = _async_loops.get(name)
+    if loop is None or loop.is_closed() or not loop.is_running():
+        return
+
+    try:
+        loop.call_soon_threadsafe(_dump_async_state, name, filename)
+    except RuntimeError:
+        pass
+
+
+# Start the monitor in a background daemon thread
+monitor_thread = threading.Thread(
+    target=dump_stacks_to_file,
+    args=(".cecli/logs/threads.log", 5, 10),  # Clears every 10 prints
+    daemon=True,
+)
+monitor_thread.start()

{cecli_dev-1.6.0rc4 → cecli_dev-1.6.0rc5}/cecli/mcp/manager.py

@@ -8,6 +8,9 @@ from cecli.tools.utils.registry import ToolRegistry
 # backstop, covering time the transport spends outside the SDK's read timeout.
 CONNECT_BACKSTOP_GRACE_SECONDS = 5
 
+# Servers whose failures are expected in normal operation and should not warn.
+QUIET_SERVER_NAMES = {"unnamed-server", "local"}
+
 
 class McpServerManager:
     """
@@ -387,14 +390,39 @@ class McpServerManager:
 
             return (server, success, True)
 
-        results = await asyncio.gather(*(_connect(server) for server in self._servers))
+        # return_exceptions=True keeps one bad server from aborting the batch and
+        # discarding every other server's result. A CancelledError that a
+        # transport raises for an ordinary connection failure lands in the
+        # results as a value; a genuine cancellation of this task still
+        # propagates through the gather itself, so it is not swallowed here.
+        outcomes = await asyncio.gather(
+            *(_connect(server) for server in self._servers), return_exceptions=True
+        )
+
+        results = []
+        for server, outcome in zip(self._servers, outcomes):
+            if isinstance(outcome, BaseException):
+                if isinstance(outcome, asyncio.CancelledError) and task_is_cancelling():
+                    # A genuine cancellation of this task must not be downgraded
+                    # to a failed server; let it propagate to the caller.
+                    raise outcome
+
+                # CancelledError discards its arguments, so fall back to the
+                # type name rather than reporting an empty cause.
+                cause = str(outcome) or type(outcome).__name__
+
+                if server.name.lower() not in QUIET_SERVER_NAMES:
+                    self._log_warning(f"MCP server {server.name} failed to initialize: {cause}")
+
+                # Reported here with its cause already, so flag it as
+                # not-attempted to keep the generic warning below from
+                # repeating the same failure.
+                results.append((server, False, False))
+            else:
+                results.append(outcome)
 
         for server, did_connect, attempted in results:
-            if (
-                attempted
-                and not did_connect
-                and server.name.lower() not in ["unnamed-server", "local"]
-            ):
+            if attempted and not did_connect and server.name.lower() not in QUIET_SERVER_NAMES:
                 self._log_warning(
                     f"MCP tool initialization failed after multiple retries: {server.name}"
                 )

{cecli_dev-1.6.0rc4 → cecli_dev-1.6.0rc5}/cecli/models.py

@@ -1487,7 +1487,7 @@ class Model(ModelSettings):
                 completion_coro = litellm.acompletion(**kwargs)
                 res, interrupted = await coroutines.interruptible(completion_coro, interrupt_event)
                 if interrupted:
-                    raise KeyboardInterrupt("Interrupted during acompletion")
+                    raise asyncio.CancelledError("Interrupted during acompletion")
 
                 return hash_object, res
             except litellm.ContextWindowExceededError as err:
@@ -1532,7 +1532,7 @@ class Model(ModelSettings):
                         asyncio.sleep(retry_delay), interrupt_event
                     )
                     if interrupted:
-                        raise KeyboardInterrupt("Interrupted during retry sleep")
+                        raise asyncio.CancelledError("Interrupted during retry sleep")
                 else:
                     await asyncio.sleep(retry_delay)
                 continue

{cecli_dev-1.6.0rc4 → cecli_dev-1.6.0rc5}/cecli/repo.py

@@ -42,6 +42,11 @@ ANY_GIT_ERROR = tuple(ANY_GIT_ERROR)
 
 git.Git.USE_SHELL = False
 
+# A malformed git tree can make ``next(iterator)`` raise IndexError without
+# advancing. Cap the retries so traversal cannot spin forever while holding
+# ``_git_lock``, which would wedge every other git operation.
+MAX_TREE_INDEX_ERRORS = 3
+
 
 @contextlib.contextmanager
 def set_git_env(var_name, value, original_value):
@@ -559,23 +564,28 @@ class GitRepo:
                 else:
                     try:
                         iterator = commit.tree.traverse()
-                        blob = None  # Initialize blob
+                        index_errors = 0
                         while True:
                             try:
                                 blob = next(iterator)
+                            except StopIteration:
+                                break
+                            except IndexError:
+                                # next() cannot advance past the entry that
+                                # raised, so retrying would spin forever while
+                                # holding _git_lock. Give up after a few tries.
+                                index_errors += 1
+                                if index_errors > MAX_TREE_INDEX_ERRORS:
+                                    self.io.tool_warning(
+                                        "GitRepo: Index error encountered while reading git tree"
+                                        " object. Skipping remaining entries."
+                                    )
+                                    break
+                                continue
+                            else:
                                 if blob.type == "blob":  # blob is a file
                                     # Use sys.intern() to deduplicate path strings in memory
                                     files.add(sys.intern(blob.path))
-                            except IndexError:
-                                # Handle potential index error during tree traversal
-                                # without relying on potentially unassigned 'blob'
-                                self.io.tool_warning(
-                                    "GitRepo: Index error encountered while reading git tree object."
-                                    " Skipping."
-                                )
-                                continue
-                            except StopIteration:
-                                break
                     except ANY_GIT_ERROR as err:
                         self.git_repo_error = err
                         self.io.tool_error(f"Unable to list files in git repo: {err}")
@@ -964,7 +974,9 @@ class GitRepoProxy:
     def __init__(self, target):
         self._target = target
         self._executor = concurrent.futures.ThreadPoolExecutor(
-            max_workers=1, thread_name_prefix="git-repo"
+            max_workers=1,
+            thread_name_prefix="git-repo",
+            initializer=_mark_git_executor_thread,
         )
 
     _instances: dict[str, "GitRepoProxy"] = {}
@@ -1048,8 +1060,21 @@ class GitRepoProxy:
 
     def __del__(self):
         try:
-            if hasattr(self, "_target") and self._target is not None:
+            if not (hasattr(self, "_target") and self._target is not None):
+                return
+
+            # Finalization can run on the executor thread itself (e.g. when
+            # garbage collection happens inside a git call). Submitting would
+            # make the single worker wait on itself, so tear down inline there.
+            if getattr(_git_executor_thread, "active", False):
+                self._target.__del__()
+                return
+
+            try:
                 self._executor.submit(self._target.__del__).result(timeout=5)
+            except RuntimeError:
+                # Executor already shut down: no worker will pick this up.
+                self._target.__del__()
         except Exception:
             pass
 
@@ -1129,3 +1154,13 @@ class GitRepoProxy:
             super().__setattr__(name, value)
         else:
             setattr(self._target, name, value)
+
+
+# Marks worker threads created by a ``GitRepoProxy`` executor. Re-entrant work
+# (e.g. a finalizer running during garbage collection on the executor thread)
+# must run inline: resubmitting to the single-worker pool would deadlock.
+_git_executor_thread = threading.local()
+
+
+def _mark_git_executor_thread():
+    _git_executor_thread.active = True

{cecli_dev-1.6.0rc4 → cecli_dev-1.6.0rc5}/cecli/tools/command.py

@@ -527,11 +527,26 @@ class Tool(BaseTool):
                 f"Output captured so far:\n{output_content}\n"
             )
             return response
+        except asyncio.CancelledError:
+            # The turn was cancelled (e.g. worker.interrupt) before the process
+            # finished. Terminate and unregister it so the child, its
+            # reader/writer threads, and the wait_task thread don't outlive the
+            # interrupted turn.
+            success, _, _ = BackgroundCommandManager.stop_background_command(command_key)
+            if not success:
+                cls._terminate_process(process)
+
+            raise
         finally:
             interrupt_task.cancel()
             timeout_task.cancel()
 
-            if wait_task.done() and not wait_task.cancelled():
+            if not wait_task.done() and process.returncode is not None:
+                # The process was terminated (interrupt/cancel) but wait_task
+                # is still pending; cancel the await. The blocked executor
+                # thread is freed once the process exits.
+                wait_task.cancel()
+            elif wait_task.done() and not wait_task.cancelled():
                 # Retrieve any exception to avoid "task exception was never
                 # retrieved" warnings. On timeout the process continues in the
                 # background, so wait_task may legitimately still be pending.
@@ -844,3 +859,28 @@ class Tool(BaseTool):
 
         # Output footer
         tool_footer(coder=coder, tool_response=tool_response, params=params)
+
+    @classmethod
+    def _terminate_process(cls, process):
+        """Terminate a foreground command process, killing it if it lingers.
+
+        Best-effort and never raises, so an interrupt handler can call it while
+        unwinding without masking the original exception.
+        """
+        import subprocess
+
+        try:
+            try:
+                process.terminate()
+            except ProcessLookupError:
+                return
+
+            try:
+                process.wait(timeout=1)
+            except subprocess.TimeoutExpired:
+                try:
+                    process.kill()
+                except ProcessLookupError:
+                    pass
+        except Exception:
+            pass