drydock-cli 3.0.27__tar.gz → 3.0.28__tar.gz

{drydock_cli-3.0.27/drydock_cli.egg-info → drydock_cli-3.0.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.27
+Version: 3.0.28
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0

{drydock_cli-3.0.27 → drydock_cli-3.0.28}/drydock/__init__.py

@@ -7,4 +7,4 @@ try:
     __version__ = _version("drydock-cli")
 except PackageNotFoundError:
     # Running from source before install (e.g. PYTHONPATH dev runs).
-    __version__ = "3.0.27"
+    __version__ = "3.0.28"

{drydock_cli-3.0.27 → drydock_cli-3.0.28}/drydock/agent.py

@@ -251,6 +251,18 @@ def run(
             if tc["name"] in ("Edit", "Write"):
                 session_has_edited = True
 
+            # STOP pressed: don't run the remaining tools, but still record a
+            # paired result for each (the assistant message already lists all
+            # tool_calls — leaving one without a tool result corrupts history).
+            if _stopped():
+                state.messages.append({
+                    "role": "tool",
+                    "tool_call_id": tc["id"],
+                    "name": tc["name"],
+                    "content": "[skipped — stopped by user]",
+                })
+                continue
+
             # Check tool call limit
             if max_tool_calls > 0 and tool_call_count > max_tool_calls:
                 state.messages.append({

{drydock_cli-3.0.27 → drydock_cli-3.0.28}/drydock/providers.py

@@ -7,11 +7,22 @@ DryDock v3 — clean rewrite, no model-specific tool call parsers.
 """
 from __future__ import annotations
 
+import concurrent.futures
 import json
 import os
 from dataclasses import dataclass
 from typing import Generator
 
+# Run blocking LLM calls here so STOP can ABANDON one mid-decode: closing the
+# HTTP client does NOT interrupt an in-flight blocking read, so instead we wait
+# on a future and, when the user cancels, return immediately and let the
+# orphaned request finish (and be discarded) in the background.
+_LLM_POOL = concurrent.futures.ThreadPoolExecutor(max_workers=8, thread_name_prefix="llm")
+
+
+class _StopRequested(Exception):
+    """Internal: STOP was pressed during a blocking LLM call."""
+
 from drydock.tuning import strip_leaked_tool_calls, strip_thinking_tokens, use_streaming
 
 # ── Provider registry ─────────────────────────────────────────────────────
@@ -71,6 +82,57 @@ def _safe_create(client, kwargs: dict, base_url: str, provider: str):
         raise LLMUnreachable(_friendly_unreachable(base_url, provider)) from e
 
 
+def _create_abortable(client, kwargs: dict, base_url: str, provider: str, cancel):
+    """Like _safe_create, but runs off-thread and polls a cancel Event so STOP
+    can abandon a blocked decode (raising _StopRequested). The orphaned request
+    runs to completion in the pool thread and its result is dropped."""
+    import openai
+
+    fut = _LLM_POOL.submit(client.chat.completions.create, **kwargs)
+    while True:
+        try:
+            return fut.result(timeout=0.2)
+        except concurrent.futures.TimeoutError:
+            if cancel is not None and cancel.is_set():
+                raise _StopRequested
+        except openai.APIConnectionError as e:
+            raise LLMUnreachable(_friendly_unreachable(base_url, provider)) from e
+
+
+def _stream_chunks(response, cancel):
+    """Yield streamed chunks, but pull them via a background thread + queue so a
+    STOP can abandon a read that's blocked waiting for the first token (the
+    thinking phase). On cancel we just stop reading; the orphaned producer
+    drains in the background."""
+    import queue as _queue
+
+    q: _queue.Queue = _queue.Queue()
+    _DONE = object()
+
+    def _produce():
+        try:
+            for ch in response:
+                q.put(ch)
+        except Exception as e:  # noqa: BLE001 — surface to the consumer
+            q.put(e)
+        finally:
+            q.put(_DONE)
+
+    _LLM_POOL.submit(_produce)
+    while True:
+        if cancel is not None and cancel.is_set():
+            return
+        try:
+            item = q.get(timeout=0.2)
+        except _queue.Empty:
+            continue
+        if item is _DONE:
+            return
+        if isinstance(item, Exception):
+            raise item
+        yield item
+
+
 # ── Event types ───────────────────────────────────────────────────────────
 
 @dataclass
@@ -196,6 +258,13 @@ def stream(
         max_retries=0,
         timeout=httpx.Timeout(600.0, connect=10.0),
     )
+    # Expose the client so the TUI's STOP (Esc / Ctrl+C) can close it mid-call —
+    # closing the connection aborts an in-flight blocking decode immediately
+    # instead of waiting out the whole generation.
+    cancel = config.get("_cancel")
+    # Stash in the SHARED abort holder (a mutable dict that survives run()'s
+    # dict(config) shallow-copy) so the TUI's STOP can reach this exact client.
+    config.setdefault("_abort", {})["client"] = client
 
     oai_messages = messages_to_openai(messages, system)
 
@@ -231,16 +300,30 @@ def stream(
     if not do_stream:
         # Non-streaming: one request, parse the complete message. This is the
         # reliable path for local models whose tool-call JSON breaks under
-        # streaming.
-        yield from _complete_nonstreaming(client, kwargs, base_url, provider)
+        # streaming. If STOP closes the client mid-call the blocking request
+        # raises — swallow that as a clean cancel rather than an error.
+        try:
+            yield from _complete_nonstreaming(client, kwargs, base_url, provider, cancel)
+        except _StopRequested:
+            return  # STOP — abandon the in-flight request, clean stop
+        except Exception:
+            if cancel is not None and cancel.is_set():
+                return
+            raise
+        finally:
+            config.get("_abort", {}).pop("client", None)
         return
 
     text = ""
     tool_buf: dict = {}  # index → {id, name, args}
     in_tok = out_tok = 0
 
-    response = _safe_create(client, kwargs, base_url, provider)
-    for chunk in response:
+    try:
+        response = _create_abortable(client, kwargs, base_url, provider, cancel)
+    except _StopRequested:
+        config.get("_abort", {}).pop("client", None)
+        return
+    for chunk in _stream_chunks(response, cancel):
         if not chunk.choices:
             if hasattr(chunk, "usage") and chunk.usage:
                 in_tok = chunk.usage.prompt_tokens or in_tok
@@ -279,6 +362,9 @@ def stream(
             in_tok = chunk.usage.prompt_tokens or in_tok
             out_tok = chunk.usage.completion_tokens or out_tok
 
+    config.get("_abort", {}).pop("client", None)  # generation done — drop the abort handle
+    if cancel is not None and cancel.is_set():
+        return  # stopped mid-stream — don't emit a partial turn
     tool_calls = []
     for idx in sorted(tool_buf):
         v = tool_buf[idx]
@@ -293,12 +379,13 @@ def stream(
 
 
 def _complete_nonstreaming(
-    client, kwargs: dict, base_url: str = "", provider: str = ""
+    client, kwargs: dict, base_url: str = "", provider: str = "", cancel=None
 ) -> Generator:
     """Single non-streaming completion. Yields one TextChunk (if any text)
     then the AssistantTurn. Used when streaming would corrupt tool-call JSON.
+    Runs off-thread so STOP can abandon a blocked decode.
     """
-    resp = _safe_create(client, kwargs, base_url, provider)
+    resp = _create_abortable(client, kwargs, base_url, provider, cancel)
     choice = resp.choices[0]
     msg = choice.message
 

{drydock_cli-3.0.27 → drydock_cli-3.0.28}/drydock/tools/__init__.py

@@ -10,6 +10,7 @@ import re
 import difflib
 import glob as _glob
 import subprocess
+import time
 from pathlib import Path
 
 from drydock.tool_registry import ToolDef, register
@@ -457,26 +458,46 @@ def tool_bash(params: dict, config: dict) -> str:
                     f"REFUSED: you declined to approve this command "
                     f"({approval_reason}).\nCommand: {cmd.strip()}"
                 )
+    # Run via Popen (not subprocess.run) so STOP can kill it mid-execution:
+    # the handle is stashed in config["_abort"]["proc"] for action_stop to .kill().
+    # We poll communicate() in short slices, checking the cancel Event and the
+    # overall timeout between slices.
+    cancel = config.get("_cancel")
+    proc = None
     try:
-        result = subprocess.run(
-            cmd, shell=True, capture_output=True, text=True,
-            timeout=timeout, cwd=config.get("cwd"),
+        proc = subprocess.Popen(
+            cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+            text=True, cwd=config.get("cwd"),
         )
-        output = result.stdout
-        if result.stderr:
-            output += "\n" + result.stderr if output else result.stderr
-        if result.returncode != 0:
-            output += f"\n[exit code: {result.returncode}]"
+        config.setdefault("_abort", {})["proc"] = proc
+        start = time.monotonic()
+        while True:
+            try:
+                out, _ = proc.communicate(timeout=0.5)
+                break
+            except subprocess.TimeoutExpired:
+                if cancel is not None and cancel.is_set():
+                    proc.kill()
+                    proc.communicate()
+                    return "[stopped by user]"
+                if time.monotonic() - start > timeout:
+                    proc.kill()
+                    proc.communicate()
+                    bigger = min(timeout * 4, 600)
+                    return (
+                        f"Error: command timed out after {timeout}s. If it is "
+                        f"legitimately slow (a big query, build, download, or "
+                        f"test run), retry with a larger timeout — pass "
+                        f"timeout: {bigger}. Otherwise it may be hung."
+                    )
+        output = out or ""
+        if proc.returncode != 0:
+            output += f"\n[exit code: {proc.returncode}]"
         return output.strip() or "(no output)"
-    except subprocess.TimeoutExpired:
-        bigger = min(timeout * 4, 600)
-        return (
-            f"Error: command timed out after {timeout}s. If it is legitimately "
-            f"slow (a big query, build, download, or test run), retry with a "
-            f"larger timeout — pass timeout: {bigger}. Otherwise it may be hung."
-        )
     except Exception as e:
         return f"Error: {e}"
+    finally:
+        config.get("_abort", {}).pop("proc", None)
 
 
 def tool_glob(params: dict, config: dict) -> str:

{drydock_cli-3.0.27 → drydock_cli-3.0.28}/drydock/tui/app.py

@@ -135,20 +135,40 @@ class DrydockApp(App):
     ]
 
     def action_stop(self) -> None:
-        """STOP the running turn: signal the agent loop to end at its next safe
-        point, drop any queued prompts, and hand control back. The session
-        (history, files) is preserved — this is not a quit."""
+        """STOP the running turn NOW (Esc or, while busy, a single Ctrl+C):
+        signal the loop AND forcibly abort the in-flight LLM call and any
+        running command so it stops immediately rather than after the current
+        step. Session (history, files) is preserved — this is not a quit."""
         if not self._busy:
             return
         self._cancel.set()
+        self._abort_inflight()
         dropped = len(self._queue)
         self._queue.clear()
-        note = "⏹ stopping after the current step…"
-        if dropped:
-            note += f" (discarded {dropped} queued)"
+        note = "⏹ stopped." + (f" (discarded {dropped} queued)" if dropped else "")
         self._info(note)
         self._refresh_status()
 
+    def _abort_inflight(self) -> None:
+        """Forcibly interrupt blocking work so STOP is immediate: close the LLM
+        HTTP client (aborts a long decode) and kill any running command. The
+        handles live in the shared config["_abort"] holder (a mutable dict that
+        survives run()'s dict(config) copy); missing ones just mean nothing is
+        in that state right now."""
+        abort = self.config.get("_abort") or {}
+        client = abort.get("client")
+        if client is not None:
+            try:
+                client.close()
+            except Exception:  # noqa: BLE001
+                pass
+        proc = abort.get("proc")
+        if proc is not None:
+            try:
+                proc.kill()
+            except Exception:  # noqa: BLE001
+                pass
+
     def action_scroll_up(self) -> None:
         self._scroll.scroll_page_up()
 
@@ -186,7 +206,12 @@ class DrydockApp(App):
             self.notify(f"Copied {len(selected)} chars to clipboard", timeout=2)
             self._ctrl_c_armed = False
             return
-        # No selection → double-Ctrl+C to exit.
+        # While a turn is running, a single Ctrl+C STOPS it (like Esc) — the
+        # interrupt key when you need to halt the TUI mid-task.
+        if self._busy:
+            self.action_stop()
+            return
+        # Idle, no selection → double-Ctrl+C to exit.
         if self._ctrl_c_armed:
             self.exit()
             return
@@ -210,6 +235,10 @@ class DrydockApp(App):
         # so run() — and any sub-agent that copies config — can see it.
         self._cancel = threading.Event()
         self.config["_cancel"] = self._cancel
+        # Shared abort-handle holder: the provider stashes the live LLM client
+        # and the bash tool its subprocess here, so STOP can force-abort them.
+        # A plain dict survives run()'s dict(config) shallow copy by reference.
+        self.config["_abort"] = {}
         self._queue: list[str] = []  # prompts submitted while a turn is running
         self._ctx_tokens = 0  # current context size (last turn's prompt tokens)
         self._ctrl_c_armed = False  # first Ctrl+C arms; second within ~2s exits
@@ -283,8 +312,10 @@ class DrydockApp(App):
         pct = min(100, round(used / limit * 100)) if limit else 0
         ctx = f"ctx {used:,}/{limit // 1000}k ({pct}%)"
         flag = "⚓ working" if self._busy else "⚓ ready"
+        # Busy → show the interrupt keys; idle → the quit hint.
+        keys = "Esc/Ctrl+C stop" if self._busy else "Ctrl+C×2 quit"
         return (
-            f"{flag}  ·  {model}  ·  Ctrl+C×2 quit · PgUp/PgDn scroll · "
+            f"{flag}  ·  {model}  ·  {keys} · PgUp/PgDn scroll · "
             f"Ctrl+O details  ·  {ctx}"
         )
 

{drydock_cli-3.0.27 → drydock_cli-3.0.28/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.27
+Version: 3.0.28
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0

{drydock_cli-3.0.27 → drydock_cli-3.0.28}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 # PyPI distribution name is drydock-cli (the established install name, continued
 # from the retired v2 fork); the import package + CLI command stay `drydock`.
 name = "drydock-cli"
-version = "3.0.27"
+version = "3.0.28"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.12"

{drydock_cli-3.0.27 → drydock_cli-3.0.28}/tests/test_stop.py

@@ -62,3 +62,28 @@ def test_no_cancel_event_runs_normally(monkeypatch):
     st = AgentState()
     list(run("go", st, {"model": "m"}, "sys"))
     assert any(m.get("role") == "assistant" for m in st.messages)
+
+
+def test_create_abortable_raises_on_cancel():
+    """_create_abortable runs the blocking call off-thread and abandons it when
+    the cancel Event fires — so STOP doesn't wait out a long decode."""
+    import threading
+    import time
+    import pytest
+    from drydock.providers import _create_abortable, _StopRequested
+
+    cancel = threading.Event()
+
+    class _SlowClient:
+        class chat:
+            class completions:
+                @staticmethod
+                def create(**kw):
+                    time.sleep(30)  # simulate a long decode (orphaned on cancel)
+                    return "never"
+
+    threading.Timer(0.3, cancel.set).start()
+    t0 = time.monotonic()
+    with pytest.raises(_StopRequested):
+        _create_abortable(_SlowClient(), {}, "", "", cancel)
+    assert time.monotonic() - t0 < 5  # returned promptly, didn't wait 30s

{drydock_cli-3.0.27 → drydock_cli-3.0.28}/tests/test_streaming_newlines.py

@@ -36,7 +36,7 @@ def test_streaming_preserves_newline_only_chunks(monkeypatch):
         _Chunk("\n\n"),
         _Chunk("body text"),
     ]
-    monkeypatch.setattr(P, "_safe_create", lambda *a, **k: iter(chunks))
+    monkeypatch.setattr(P, "_create_abortable", lambda *a, **k: iter(chunks))
 
     full = ""
     streamed = []
@@ -60,7 +60,7 @@ def test_streaming_still_drops_chunk_emptied_by_stripping(monkeypatch):
     # A chunk that is ONLY a thinking marker strips to "" and is skipped (so we
     # don't emit empty text), but real whitespace is kept.
     chunks = [_Chunk("hello"), _Chunk("<|channel>x<channel|>"), _Chunk("\n"), _Chunk("world")]
-    monkeypatch.setattr(P, "_safe_create", lambda *a, **k: iter(chunks))
+    monkeypatch.setattr(P, "_create_abortable", lambda *a, **k: iter(chunks))
     full = ""
     for ev in stream(model="gemma4", system="s",
                      messages=[{"role": "user", "content": "hi"}],