drydock-cli 3.0.85__tar.gz → 3.0.87__tar.gz

{drydock_cli-3.0.85/drydock_cli.egg-info → drydock_cli-3.0.87}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.85
+Version: 3.0.87
 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.85 → drydock_cli-3.0.87}/drydock/agent.py

@@ -63,6 +63,7 @@ class AgentState:
     messages: list = field(default_factory=list)
     total_input_tokens: int = 0
     total_output_tokens: int = 0
+    last_input_tokens: int = 0  # prompt tokens the SERVER counted on the last call
     turn_count: int = 0
     current_effort: str = ""  # "high"/"low" of the in-flight LLM call (for the UI)
 
@@ -210,6 +211,7 @@ def run(
 
         state.total_input_tokens += assistant_turn.input_tokens
         state.total_output_tokens += assistant_turn.output_tokens
+        state.last_input_tokens = assistant_turn.input_tokens
         yield TurnDone(assistant_turn.input_tokens, assistant_turn.output_tokens)
 
         # No tool calls = conversation complete — UNLESS the model emitted a

{drydock_cli-3.0.85 → drydock_cli-3.0.87}/drydock/compaction.py

@@ -192,9 +192,16 @@ def emergency_compact(messages: list, context_limit: int = 131072) -> list:
 
 
 def maybe_compact(state, config: dict) -> None:
-    """Compact state.messages if approaching context limit."""
+    """Compact state.messages if approaching context limit.
+
+    Uses the MAX of the char-based estimate and the SERVER's real prompt-token
+    count from the last call. estimate_tokens (chars/3.5) undercounts token-dense
+    content — code, compiler/build output, tracebacks tokenize to ~3 chars/token
+    — so on such tasks the real context (what the gauge shows) can pass 60% while
+    the estimate is still under it, and compaction fires late. The real count
+    catches that."""
     limit = config.get("context_limit", 131072)
-    current = estimate_tokens(state.messages)
+    current = max(estimate_tokens(state.messages), getattr(state, "last_input_tokens", 0))
 
     if current > limit * 0.60:
         state.messages = compact(state.messages, limit)

{drydock_cli-3.0.85 → drydock_cli-3.0.87}/drydock/tui/app.py

@@ -59,6 +59,12 @@ BANNER = (
 # Animated "working" line: a turning-helm arc spinner + a nautical gerund +
 # elapsed time + streamed-token count. Rendered in-line above the status bar.
 _SPINNER = "◜◠◝◞◡◟"
+# No agent event for this long → the activity line warns the model may be stalled
+# (the gemma llama.cpp server can hang mid-generation on hard prompts). Advisory
+# only. Set above the longest LEGIT silent stretch seen (a ~135s high-effort
+# think before the first tool call) so normal slow turns don't nag; observed
+# stalls ran 3–5 min+, so 180s still flags them well before the 30-min timeout.
+_STALL_HINT_SECS = 180
 _WORKING_WORDS = [
     "Battening", "Splicing", "Hoisting", "Heaving", "Trimming", "Tacking",
     "Mooring", "Charting", "Navigating", "Sounding", "Caulking", "Rigging",
@@ -262,6 +268,7 @@ class DrydockApp(App):
         self._work_start = 0.0
         self._work_word = ""
         self._work_chars = 0   # streamed output chars this turn (→ ~tokens)
+        self._last_progress = 0.0  # monotonic time of the last agent event (stall watchdog)
         self._spinner_i = 0
 
         # The agent (worker thread) calls this to gate a sensitive command on
@@ -349,7 +356,13 @@ class DrydockApp(App):
         effort = self.state.current_effort
         eff = f" · thinking with {effort} effort" if effort else ""
         queued = f" · {len(self._queue)} queued" if self._queue else ""
-        return f"{spin} {self._work_word}…  ({elapsed} · ↓ {toks} tokens{eff}{queued})"
+        # Stall watchdog (advisory): if no agent event has arrived for a while,
+        # the model server may be hung. Flag it so the user isn't left guessing
+        # whether it's thinking or stalled — but never act (Esc is theirs).
+        silent = time.monotonic() - self._last_progress if self._last_progress else 0.0
+        stall = (f"  ⚠ no output for {int(silent)}s — the model may be slow or stalled; "
+                 "Esc to stop") if silent > _STALL_HINT_SECS else ""
+        return f"{spin} {self._work_word}…  ({elapsed} · ↓ {toks} tokens{eff}{queued}){stall}"
 
     def _refresh_status(self) -> None:
         # The 0.18s _tick_work timer can fire one last time DURING app teardown,
@@ -435,6 +448,7 @@ class DrydockApp(App):
         self.query_one("#todo", Static).update("")
         self._busy = True
         self._work_start = time.monotonic()
+        self._last_progress = self._work_start
         self._work_word = random.choice(_WORKING_WORDS)
         self._work_chars = 0
         self._spinner_i = 0
@@ -1133,6 +1147,11 @@ class DrydockApp(App):
     def _run_agent(self, text: str) -> None:
         try:
             for ev in run(text, self.state, self.config, self.system):
+                # Any event = the model/server is making progress → reset the
+                # stall watchdog. During a real stall the provider stream blocks
+                # and NO event arrives, so this timestamp freezes and
+                # _working_text surfaces a hint.
+                self._last_progress = time.monotonic()
                 if isinstance(ev, ReasoningChunk):
                     self.post_message(AgentReasoning(ev.text))
                 elif isinstance(ev, TextChunk):

{drydock_cli-3.0.85 → drydock_cli-3.0.87/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.85
+Version: 3.0.87
 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.85 → drydock_cli-3.0.87}/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.85"
+version = "3.0.87"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.11"

drydock_cli-3.0.87/tests/test_compact_command.py

@@ -0,0 +1,91 @@
+"""The /compact slash command (advertised in /help) must actually compact:
+wire it to compaction.compact and report tokens freed. Regression for the gap
+where /help listed /compact but handle_command never implemented it."""
+from __future__ import annotations
+
+from drydock import cli
+from drydock.agent import AgentState
+from drydock.compaction import estimate_tokens
+
+
+def _state_with_big_tool_result() -> AgentState:
+    state = AgentState()
+    state.messages = [
+        {"role": "user", "content": "do a thing"},
+        {
+            "role": "assistant",
+            "content": "",
+            "tool_calls": [{"id": "c1", "name": "Bash", "input": {"command": "cat big"}}],
+        },
+        {"role": "tool", "tool_call_id": "c1", "content": "Z" * 8000},
+        {"role": "assistant", "content": "done"},
+    ]
+    return state
+
+
+def test_compact_command_is_handled():
+    """/compact returns True (handled), not False (falls through to the agent)."""
+    state = AgentState()
+    assert cli.handle_command("/compact", state, {"context_limit": 65536}) is True
+
+
+def test_compact_shrinks_a_bloated_conversation(capsys):
+    state = _state_with_big_tool_result()
+    before = estimate_tokens(state.messages)
+
+    cli.handle_command("/compact", state, {"context_limit": 65536})
+
+    after = estimate_tokens(state.messages)
+    assert after < before  # the 8000-char tool result was truncated
+    out = capsys.readouterr().out.lower()
+    assert "compact" in out and "freed" in out
+
+
+def test_compact_on_empty_conversation_is_a_noop(capsys):
+    state = AgentState()
+    assert cli.handle_command("/compact", state, {"context_limit": 65536}) is True
+    assert "nothing to compact" in capsys.readouterr().out.lower()
+
+
+def test_maybe_compact_uses_real_token_count_not_just_estimate():
+    """maybe_compact must trigger on the SERVER's real prompt-token count, not
+    only the chars/3.5 estimate (which undercounts dense code/build output).
+    Regression: build task hit 64% real ctx without compacting because the
+    estimate read ~55%."""
+    from drydock.agent import AgentState
+    from drydock.compaction import maybe_compact, estimate_tokens
+
+    st = AgentState()
+    # A few small messages: the char estimate is tiny (well under 60% of 65536)…
+    st.messages = [
+        {"role": "user", "content": "hi"},
+        {"role": "assistant", "content": "hello", "tool_calls": []},
+    ]
+    assert estimate_tokens(st.messages) < 0.60 * 65536      # estimate says "fine"
+    cfg = {"context_limit": 65536}
+    # …but the server reported a large real prompt (dense content) → must compact.
+    st.last_input_tokens = 45000                            # 68% of 65536
+    before = list(st.messages)
+    maybe_compact(st, cfg)
+    # compact() ran (it targets 60%); with only tiny messages it can't shrink, but
+    # the point is it was INVOKED on the real count — verify the trigger path by
+    # checking a case with droppable content:
+    st.messages = before + [
+        {"role": "assistant", "content": "", "tool_calls": [{"id": "a", "name": "Bash", "input": {"command": "x"}}]},
+        {"role": "tool", "tool_call_id": "a", "name": "Bash", "content": "Z" * 200000},  # huge old tool result
+    ]
+    st.last_input_tokens = 45000
+    maybe_compact(st, cfg)
+    # the huge old tool result should be trimmed by compact()
+    assert estimate_tokens(st.messages) < estimate_tokens(before + [{"role": "tool", "content": "Z" * 200000}])
+
+
+def test_maybe_compact_low_real_count_no_trigger():
+    from drydock.agent import AgentState
+    from drydock.compaction import maybe_compact
+    st = AgentState()
+    st.messages = [{"role": "user", "content": "small"}]
+    st.last_input_tokens = 1000
+    before = list(st.messages)
+    maybe_compact(st, {"context_limit": 65536})
+    assert st.messages == before      # nothing to do, unchanged

{drydock_cli-3.0.85 → drydock_cli-3.0.87}/tests/test_tui.py

@@ -457,3 +457,29 @@ def test_ask_bang_injects_advice_but_plain_ask_does_not():
             assert started == []
 
     asyncio.run(main())
+
+
+def test_stall_watchdog_hint_appears_after_silence():
+    """The activity line warns when no agent event has arrived for a while
+    (a hung model server) — advisory, and it clears once progress resumes."""
+    import time as _time
+    from drydock.tui.app import _STALL_HINT_SECS
+
+    async def main():
+        app = DrydockApp({"model": "gemma4", "provider": "vllm", "cwd": "/tmp"})
+        async with app.run_test() as pilot:
+            await pilot.pause()
+            app._busy = True
+            app._work_start = _time.monotonic()
+            app._work_word = "Working"
+            # fresh progress → no hint
+            app._last_progress = _time.monotonic()
+            assert "stalled" not in app._working_text()
+            # simulate silence beyond the threshold → hint appears
+            app._last_progress = _time.monotonic() - (_STALL_HINT_SECS + 5)
+            assert "stalled" in app._working_text() and "Esc to stop" in app._working_text()
+            # progress resumes → hint clears
+            app._last_progress = _time.monotonic()
+            assert "stalled" not in app._working_text()
+
+    asyncio.run(main())

drydock_cli-3.0.85/tests/test_compact_command.py

@@ -1,47 +0,0 @@
-"""The /compact slash command (advertised in /help) must actually compact:
-wire it to compaction.compact and report tokens freed. Regression for the gap
-where /help listed /compact but handle_command never implemented it."""
-from __future__ import annotations
-
-from drydock import cli
-from drydock.agent import AgentState
-from drydock.compaction import estimate_tokens
-
-
-def _state_with_big_tool_result() -> AgentState:
-    state = AgentState()
-    state.messages = [
-        {"role": "user", "content": "do a thing"},
-        {
-            "role": "assistant",
-            "content": "",
-            "tool_calls": [{"id": "c1", "name": "Bash", "input": {"command": "cat big"}}],
-        },
-        {"role": "tool", "tool_call_id": "c1", "content": "Z" * 8000},
-        {"role": "assistant", "content": "done"},
-    ]
-    return state
-
-
-def test_compact_command_is_handled():
-    """/compact returns True (handled), not False (falls through to the agent)."""
-    state = AgentState()
-    assert cli.handle_command("/compact", state, {"context_limit": 65536}) is True
-
-
-def test_compact_shrinks_a_bloated_conversation(capsys):
-    state = _state_with_big_tool_result()
-    before = estimate_tokens(state.messages)
-
-    cli.handle_command("/compact", state, {"context_limit": 65536})
-
-    after = estimate_tokens(state.messages)
-    assert after < before  # the 8000-char tool result was truncated
-    out = capsys.readouterr().out.lower()
-    assert "compact" in out and "freed" in out
-
-
-def test_compact_on_empty_conversation_is_a_noop(capsys):
-    state = AgentState()
-    assert cli.handle_command("/compact", state, {"context_limit": 65536}) is True
-    assert "nothing to compact" in capsys.readouterr().out.lower()