drydock-cli 3.0.18__tar.gz → 3.0.20__tar.gz

{drydock_cli-3.0.18/drydock_cli.egg-info → drydock_cli-3.0.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.18
+Version: 3.0.20
 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.18 → drydock_cli-3.0.20}/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.18"
+    __version__ = "3.0.20"

{drydock_cli-3.0.18 → drydock_cli-3.0.20}/drydock/agent.py

@@ -103,6 +103,13 @@ def run(
     # a call to anything else is refused — never executed. Keeps a read-only
     # sub-agent read-only and stops it from recursing into `task`.
     allow = config.get("tool_allowlist")
+    # User STOP signal (a threading.Event the TUI sets on Escape / "/stop").
+    # Checked only at SAFE points — top of the loop and after a turn's tool
+    # results are all appended — so a stop never leaves an assistant tool_call
+    # without its matching tool result (which would corrupt the history).
+    cancel = config.get("_cancel")
+    def _stopped() -> bool:
+        return cancel is not None and cancel.is_set()
     tool_call_count = 0
     session_has_edited = False
     leaked_call_retries = 0
@@ -111,6 +118,8 @@ def run(
     loop_tracker = LoopTracker()
 
     while state.turn_count < max_turns:
+        if _stopped():
+            break
         state.turn_count += 1
         run_iteration += 1
         assistant_turn: AssistantTurn | None = None
@@ -264,6 +273,11 @@ def run(
                 "content": result,
             })
 
+        # Safe point (all tool results appended): honor a STOP requested while
+        # this turn's tools were running, before spending another LLM call.
+        if _stopped():
+            break
+
         # Real progress this turn — reset the consecutive stall-nudge counter so
         # a long, productive plan can run as far as it needs (the cap only
         # bounds back-to-back stalls).

{drydock_cli-3.0.18 → drydock_cli-3.0.20}/drydock/compaction.py

@@ -35,18 +35,52 @@ def is_context_length_error(err: str) -> bool:
 
 
 def estimate_tokens(messages: list) -> int:
-    """Rough token estimate: chars / 3.5"""
+    """Rough token estimate: chars / 3.5.
+
+    CRUCIAL: a tool call's arguments live in a nested ``input`` dict — e.g. a
+    full-file Write puts the whole file in tool_calls[].input.content. Counting
+    only top-level strings missed that entirely, so a 40k-char Write read as ~0
+    tokens, compaction never fired, and the real request blew past the context
+    window. Count nested strings so the estimate reflects what's actually sent.
+    """
     total = 0
     for m in messages:
         content = m.get("content", "")
         if isinstance(content, str):
             total += len(content)
-        for tc in m.get("tool_calls", []):
-            if isinstance(tc, dict):
-                for v in tc.values():
-                    if isinstance(v, str):
-                        total += len(v)
-    return int(total / 3.5)
+        for tc in m.get("tool_calls", []) or []:
+            total += _count_chars(tc)
+    # /3.0, not /3.5: code is symbol-dense and tokenizes to MORE tokens than
+    # prose, so a conservative (slightly high) estimate keeps us off the wall.
+    return int(total / 3.0)
+
+
+def _count_chars(v) -> int:
+    """Total length of every string nested in v (str / dict / list)."""
+    if isinstance(v, str):
+        return len(v)
+    if isinstance(v, dict):
+        return sum(_count_chars(x) for x in v.values())
+    if isinstance(v, (list, tuple)):
+        return sum(_count_chars(x) for x in v)
+    return 0
+
+
+def _truncate_tool_call_args(messages: list, max_len: int) -> None:
+    """Shrink oversized string arguments inside OLD assistant tool calls (a
+    full-file Write/Edit is a top bloat source and nothing else truncates it).
+    The most recent tool-call message is left intact; truncating only the
+    argument *values* keeps each call's id, so tool-result pairing stays valid."""
+    last = max((i for i, m in enumerate(messages) if m.get("tool_calls")), default=-1)
+    for i, m in enumerate(messages):
+        if i == last:
+            continue
+        for tc in m.get("tool_calls") or []:
+            inp = tc.get("input") if isinstance(tc, dict) else None
+            if isinstance(inp, dict):
+                for k, v in inp.items():
+                    if isinstance(v, str) and len(v) > max_len:
+                        inp[k] = v[: max_len // 2] + "\n[... arg truncated ...]"
 
 
 def compact(messages: list, context_limit: int = 131072) -> list:
@@ -92,6 +126,10 @@ def compact(messages: list, context_limit: int = 131072) -> list:
             if current <= target:
                 break
 
+    # Pass 3: shrink big old tool-call arguments (full-file Write/Edit bodies).
+    if estimate_tokens(messages) > target:
+        _truncate_tool_call_args(messages, max_len=1500)
+
     return messages
 
 
@@ -135,6 +173,11 @@ def emergency_compact(messages: list, context_limit: int = 131072) -> list:
                 if isinstance(content, str) and len(content) > 500:
                     messages[i]["content"] = content[:300] + "\n[... truncated ...]"
 
+    # Pass 4: shrink big tool-CALL arguments — a full-file Write/Edit puts the
+    # whole file in tool_calls[].input and nothing above touches it. This was
+    # THE leak that let the real request stay over the window after compaction.
+    _truncate_tool_call_args(messages, max_len=300)
+
     return messages
 
 

{drydock_cli-3.0.18 → drydock_cli-3.0.20}/drydock/tui/app.py

@@ -8,6 +8,7 @@ messages (see tui/messages.py). Nautical theme, original branding.
 from __future__ import annotations
 
 import random
+import threading
 import time
 
 from textual import work
@@ -119,6 +120,10 @@ class DrydockApp(App):
     BINDINGS = [
         Binding("ctrl+c", "copy_selection", "Copy", priority=True),
         Binding("ctrl+d", "quit", "Quit", priority=True),
+        # Escape stops a running turn (the agent ends cleanly, session kept) —
+        # the way out of a runaway task without quitting the whole app. "/stop"
+        # does the same. priority so it isn't swallowed by the focused prompt.
+        Binding("escape", "stop", "Stop the running turn", priority=True),
         Binding("ctrl+o", "toggle_tools", "Expand/collapse details"),
         # Scroll the transcript from the keyboard (focus stays on the prompt,
         # and SSH sessions often don't forward the mouse wheel). priority=True
@@ -129,6 +134,21 @@ class DrydockApp(App):
         Binding("ctrl+end", "scroll_bottom", "Bottom", priority=True, show=False),
     ]
 
+    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."""
+        if not self._busy:
+            return
+        self._cancel.set()
+        dropped = len(self._queue)
+        self._queue.clear()
+        note = "⏹ stopping after the current step…"
+        if dropped:
+            note += f" (discarded {dropped} queued)"
+        self._info(note)
+        self._refresh_status()
+
     def action_scroll_up(self) -> None:
         self._scroll.scroll_page_up()
 
@@ -185,6 +205,11 @@ class DrydockApp(App):
         self._current_assistant: AssistantMessage | None = None
         self._last_card: ToolCard | None = None
         self._busy = False
+        # STOP signal: Escape / "/stop" sets it; the agent loop checks it at safe
+        # points and ends the turn cleanly (session preserved). Lives in config
+        # so run() — and any sub-agent that copies config — can see it.
+        self._cancel = threading.Event()
+        self.config["_cancel"] = self._cancel
         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
@@ -318,6 +343,7 @@ class DrydockApp(App):
     def _begin(self, text: str) -> None:
         """Start an agent turn for an already-displayed user prompt."""
         self._current_assistant = None
+        self._cancel.clear()  # fresh turn — clear any prior STOP
         self._busy = True
         self._work_start = time.monotonic()
         self._work_word = random.choice(_WORKING_WORDS)
@@ -336,12 +362,18 @@ class DrydockApp(App):
         arg = parts[1].strip() if len(parts) > 1 else ""
         if cmd in ("/quit", "/exit", "/q"):
             self.exit()
+        elif cmd in ("/stop", "/cancel"):
+            if self._busy:
+                self.action_stop()
+            else:
+                self._info("Nothing is running.")
         elif cmd == "/clear":
             self.state = AgentState()
             self._scroll.remove_children()
             self._current_assistant = None
             self.config.pop("_todo", None)
             self.query_one("#todo", Static).update("")  # clear the pinned plan
+            self._ctx_tokens = 0  # reset the context gauge — history is empty now
             self._refresh_status()
         elif cmd == "/model":
             self._cmd_model(arg)
@@ -377,10 +409,11 @@ class DrydockApp(App):
                 "  /cwd [path]      show or change the working directory\n"
                 "  /undo            revert the last file write/edit\n"
                 "  /back            rewind the last turn from the model's context\n"
+                "  /stop            stop the running turn (or press Esc)\n"
                 "  /status          session model, cwd, turns, tokens\n"
                 "  /clear           reset the conversation\n"
                 "  /quit            exit\n"
-                "Type a task and press Enter. ↑/↓ recall history · Ctrl+O expands tools."
+                "Type a task and press Enter. ↑/↓ recall history · Esc stops · Ctrl+O expands tools."
             )
         else:
             self._mount(ErrorMessage(f"unknown command: {cmd} (try /help)"))

{drydock_cli-3.0.18 → drydock_cli-3.0.20/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.18
+Version: 3.0.20
 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.18 → drydock_cli-3.0.20}/drydock_cli.egg-info/SOURCES.txt

@@ -40,6 +40,7 @@ tests/test_leaked_tool_call.py
 tests/test_loop_detect.py
 tests/test_plan_autocontinue.py
 tests/test_providers_unreachable.py
+tests/test_stop.py
 tests/test_subagent.py
 tests/test_todo.py
 tests/test_tools_undo.py

{drydock_cli-3.0.18 → drydock_cli-3.0.20}/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.18"
+version = "3.0.20"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.12"

{drydock_cli-3.0.18 → drydock_cli-3.0.20}/tests/test_compaction.py

@@ -15,6 +15,40 @@ from drydock.compaction import (
 )
 
 
+def test_estimate_counts_tool_call_input_args():
+    # A full-file Write hides its bulk in tool_calls[].input.content. The
+    # estimate MUST see it (this was the bug: it read as ~0 tokens).
+    big = "x" * 40000
+    msgs = [{"role": "assistant", "content": "",
+             "tool_calls": [{"id": "1", "name": "Write",
+                             "input": {"file_path": "a.py", "content": big}}]}]
+    assert estimate_tokens(msgs) > 10000  # ~40000/3.0, not ~0
+
+
+def test_emergency_compact_shrinks_big_write_arg_below_limit():
+    # Reproduce the operator's crash shape: history dominated by an OLD
+    # full-file Write arg. Emergency compaction must get the estimate under the
+    # real 64k window (it returned the SAME oversized request before).
+    limit = 65536
+    big = "y" * 250000  # ~83k est tokens — over the window
+    msgs = [
+        {"role": "user", "content": "refactor cli.py"},
+        {"role": "assistant", "content": "",
+         "tool_calls": [{"id": "1", "name": "Write",
+                         "input": {"file_path": "cli.py", "content": big}}]},
+        {"role": "tool", "tool_call_id": "1", "name": "Write", "content": "ok"},
+        {"role": "user", "content": "now run tests"},
+        {"role": "assistant", "content": "",
+         "tool_calls": [{"id": "2", "name": "Bash", "input": {"command": "pytest"}}]},
+        {"role": "tool", "tool_call_id": "2", "name": "Bash", "content": "passed"},
+    ]
+    assert estimate_tokens(msgs) > limit
+    emergency_compact(msgs, limit)
+    assert estimate_tokens(msgs) < limit  # actually under the window now
+    # The recent Bash tool_call (last) is preserved intact.
+    assert msgs[4]["tool_calls"][0]["input"]["command"] == "pytest"
+
+
 def test_is_context_length_error_matches_provider_phrasings():
     for msg in [
         "This model's maximum context length is 131072 tokens",

drydock_cli-3.0.20/tests/test_stop.py

@@ -0,0 +1,64 @@
+"""STOP/interrupt: a threading.Event in config["_cancel"] lets the TUI halt a
+running turn at a safe point. The agent must (a) not start a turn when stop is
+already set, and (b) end after the current turn's tools rather than looping —
+without leaving an assistant tool_call missing its tool result."""
+from __future__ import annotations
+
+import threading
+
+import drydock.agent as agent_mod
+from drydock.agent import AgentState, run
+from drydock.providers import AssistantTurn
+
+
+def test_no_turn_when_already_stopped(monkeypatch):
+    calls = {"n": 0}
+
+    def fake_stream(**kw):
+        calls["n"] += 1
+        yield AssistantTurn("hi", [], 1, 1)
+
+    monkeypatch.setattr(agent_mod, "stream", fake_stream)
+    ev = threading.Event()
+    ev.set()
+    st = AgentState()
+    list(run("go", st, {"model": "m", "_cancel": ev}, "sys"))
+    assert calls["n"] == 0  # loop broke before any model call
+
+
+def test_stop_ends_after_current_turn(monkeypatch):
+    # The model would loop forever (always returns a tool call); a stop set
+    # during the first turn must end the run after that turn's tools.
+    calls = {"n": 0}
+    ev = threading.Event()
+
+    def fake_stream(**kw):
+        calls["n"] += 1
+        ev.set()  # user hits STOP while this turn runs
+        yield AssistantTurn(
+            "", [{"id": str(calls["n"]), "name": "Read", "input": {"file_path": "nope"}}], 1, 1
+        )
+
+    monkeypatch.setattr(agent_mod, "stream", fake_stream)
+    st = AgentState()
+    list(run("go", st, {"model": "m", "_cancel": ev}, "sys"))
+    assert calls["n"] == 1  # exactly one turn, then stopped
+
+    # History is still valid: every assistant tool_call has a matching tool msg.
+    call_ids = [
+        tc["id"]
+        for msg in st.messages
+        if msg.get("role") == "assistant"
+        for tc in (msg.get("tool_calls") or [])
+    ]
+    tool_ids = [m["tool_call_id"] for m in st.messages if m["role"] == "tool"]
+    assert sorted(call_ids) == sorted(tool_ids)
+
+
+def test_no_cancel_event_runs_normally(monkeypatch):
+    # Absent a _cancel event, behaviour is unchanged.
+    seq = [AssistantTurn("done", [], 1, 1)]
+    monkeypatch.setattr(agent_mod, "stream", lambda **kw: iter([seq.pop(0)]))
+    st = AgentState()
+    list(run("go", st, {"model": "m"}, "sys"))
+    assert any(m.get("role") == "assistant" for m in st.messages)