drydock-cli 2.8.44__tar.gz → 2.8.45__tar.gz

drydock_cli-2.8.45/.auto_release.lock

@@ -0,0 +1 @@
+2172060

{drydock_cli-2.8.44 → drydock_cli-2.8.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.8.44
+Version: 2.8.45
 Summary: Local-first CLI coding agent — tested with Gemma 4 26B via vLLM
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock

{drydock_cli-2.8.44 → drydock_cli-2.8.45}/drydock/cli/commands.py

@@ -36,6 +36,17 @@ class CommandRegistry:
                 description="Clear conversation history",
                 handler="_clear_history",
             ),
+            "undo": Command(
+                aliases=frozenset(["/undo", "/back"]),
+                description=(
+                    "Roll back the last turn — drop the most recent user "
+                    "prompt and the assistant turn it triggered. Use when "
+                    "an API error or bad tool call wedged the conversation "
+                    "and you want to retry from the previous good state "
+                    "without losing the rest of the history (unlike /clear)."
+                ),
+                handler="_undo_last_turn",
+            ),
             "log": Command(
                 aliases=frozenset(["/log"]),
                 description="Show path to current interaction log file",

{drydock_cli-2.8.44 → drydock_cli-2.8.45}/drydock/cli/textual_ui/app.py

@@ -2204,6 +2204,41 @@ class DrydockApp(App):  # noqa: PLR0904
                 )
             )
 
+    async def _undo_last_turn(self) -> None:
+        """Roll back the last user→assistant turn without wiping the
+        whole session. Safer alternative to /clear when an error
+        wedges the conversation."""
+        if self._agent_running:
+            await self._mount_and_scroll(
+                ErrorMessage(
+                    "Cannot /undo while the agent is processing. "
+                    "Press Esc to cancel first, then /undo.",
+                    collapsed=self._tools_collapsed,
+                )
+            )
+            return
+        try:
+            ok, info = await self.agent_loop.undo_last_turn()
+            if not ok:
+                await self._mount_and_scroll(
+                    ErrorMessage(info, collapsed=self._tools_collapsed)
+                )
+                return
+            # The conversation history is now rolled back. We don't try
+            # to selectively remove rendered UI widgets — that's fragile
+            # since the assistant turn we dropped may have produced
+            # multiple widgets (text, tool calls, tool results). Instead,
+            # emit a clear marker so the user sees where the rollback
+            # happened. Subsequent prompts will start fresh against the
+            # truncated message history.
+            await self._mount_and_scroll(UserCommandMessage(info))
+        except Exception as e:  # noqa: BLE001
+            await self._mount_and_scroll(
+                ErrorMessage(
+                    f"Undo failed: {e}", collapsed=self._tools_collapsed
+                )
+            )
+
     async def _clear_history(self) -> None:
         try:
             self._reset_ui_state()

{drydock_cli-2.8.44 → drydock_cli-2.8.45}/drydock/core/agent_loop.py

@@ -4373,6 +4373,70 @@ or replace freely; future sessions will respect your edits._
     def set_user_input_callback(self, callback: UserInputCallback) -> None:
         self.user_input_callback = callback
 
+    async def undo_last_turn(self) -> tuple[bool, str]:
+        """Rewind history past the LAST user message, dropping the
+        assistant turn (and any tool results) it triggered AND the
+        user message itself. Use case: the last user prompt set off
+        a chain that wedged the conversation; the user wants to back
+        out and try a different prompt.
+
+        Returns (success, info_message).
+
+        Why this is safer than `/clear`:
+          - Preserves the system message (index 0)
+          - Preserves all prior good user+assistant exchanges
+          - Resets the sticky error counters so the new prompt
+            won't immediately re-trip the lockout
+
+        Why drop the user message too (not just the assistant turn):
+          - If the user repeats the same prompt, they'll re-trigger
+            the same bad assistant response. The point of /undo is
+            to escape; the user can always re-type the prompt if
+            they really want it.
+        """
+        # Find the last user message — walk backward
+        last_user_idx = -1
+        for i in range(len(self.messages) - 1, -1, -1):
+            if self.messages[i].role == Role.user:
+                last_user_idx = i
+                break
+
+        if last_user_idx <= 0:
+            # No user message to rewind past (only the system message
+            # is present), or the user message is at idx 0 which we
+            # never drop. Nothing to undo.
+            return (False, "Nothing to undo — no prior user turn in history.")
+
+        dropped = len(self.messages) - last_user_idx
+        kept = list(self.messages[:last_user_idx])
+        try:
+            await self.session_logger.save_interaction(
+                self.messages,
+                self.stats,
+                self._base_config,
+                self.tool_manager,
+                self.agent_profile,
+            )
+        except Exception as e:  # noqa: BLE001 — never block /undo on a save failure
+            logger.warning("[undo] session save failed (continuing): %s", e)
+        self.messages.reset(kept)
+        # Clear the sticky error counters so the next prompt starts fresh.
+        if hasattr(self, "_total_error_rounds"):
+            self._total_error_rounds = 0
+        if hasattr(self, "_consecutive_circuit_breaker_fires"):
+            self._consecutive_circuit_breaker_fires = 0
+        if hasattr(self, "_consecutive_empty_turns"):
+            self._consecutive_empty_turns = 0
+        logger.warning(
+            "[undo] rolled back: kept %d messages (dropped %d after last user idx=%d)",
+            len(kept), dropped, last_user_idx,
+        )
+        return (
+            True,
+            f"Rolled back the last turn — dropped {dropped} message(s). "
+            f"Type your next prompt to continue from the prior state.",
+        )
+
     async def clear_history(self) -> None:
         await self.session_logger.save_interaction(
             self.messages,

{drydock_cli-2.8.44 → drydock_cli-2.8.45}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "2.8.44"
+version = "2.8.45"
 description = "Local-first CLI coding agent — tested with Gemma 4 26B via vLLM"
 readme = "README.md"
 requires-python = ">=3.12"

{drydock_cli-2.8.44 → drydock_cli-2.8.45}/tests/test_api_error_recovery.py

@@ -147,3 +147,49 @@ def test_conversation_loop_resets_total_error_rounds_on_entry():
     assert "_total_error_rounds" in src
     assert "= 0" in src
     assert "fresh user turn" in src or "Reset sticky error" in src
+
+
+# ── /undo slash command ────────────────────────────────────────────────
+
+def test_undo_command_registered_with_aliases():
+    """The /undo command must be in the registry with /back as alias."""
+    from drydock.cli.commands import CommandRegistry
+    r = CommandRegistry()
+    cmd = r.commands.get("undo")
+    assert cmd is not None
+    assert "/undo" in cmd.aliases
+    assert "/back" in cmd.aliases
+    assert cmd.handler == "_undo_last_turn"
+
+
+def test_agent_loop_undo_last_turn_method_exists():
+    """The agent loop must expose undo_last_turn for the TUI handler."""
+    from drydock.core.agent_loop import AgentLoop
+    assert callable(getattr(AgentLoop, "undo_last_turn", None))
+
+
+def test_undo_keeps_system_and_truncates_to_before_last_user():
+    """Validate the rewind shape: drop the last user msg + everything
+    after it; keep the system message and all prior turns."""
+    import inspect
+    from drydock.core.agent_loop import AgentLoop
+    src = inspect.getsource(AgentLoop.undo_last_turn)
+    # The implementation must walk backward to find the last user idx,
+    # then slice the messages to keep only [:last_user_idx].
+    assert "last_user_idx" in src
+    assert "Role.user" in src
+    assert ".reset(" in src
+    # It must also clear the sticky error counters so the next prompt
+    # doesn't immediately re-trip the lockout.
+    assert "_total_error_rounds" in src
+
+
+def test_undo_returns_failure_when_only_system_message():
+    """If there's no user message to rewind past, undo should return
+    (False, info) rather than wiping the system message."""
+    import inspect
+    from drydock.core.agent_loop import AgentLoop
+    src = inspect.getsource(AgentLoop.undo_last_turn)
+    # Guard condition for "no user message" or "only system message"
+    assert "last_user_idx <= 0" in src or "last_user_idx == -1" in src
+    assert "Nothing to undo" in src

drydock_cli-2.8.44/.auto_release.lock

@@ -1 +0,0 @@
-2170697