drydock-cli 2.6.1__tar.gz → 2.6.3__tar.gz

drydock_cli-2.6.3/.auto_release.lock

@@ -0,0 +1 @@
+3774888

{drydock_cli-2.6.1 → drydock_cli-2.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.6.1
+Version: 2.6.3
 Summary: Drydock — nautical CLI coding agent
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock

{drydock_cli-2.6.1 → drydock_cli-2.6.3}/drydock/core/agent_loop.py

@@ -594,174 +594,14 @@ class AgentLoop:
 
                 last_message = self.messages[-1]
 
-                # Track files explored, edits made, and bash/failure patterns
+                # Track edits — no circuit breakers, just track for has_made_edit
                 if not has_made_edit:
                     for msg in reversed(self.messages[-5:]):
                         if msg.role == Role.assistant and msg.tool_calls:
                             for tc in msg.tool_calls:
-                                if not tc.function:
-                                    continue
-                                if tc.function.name in ("search_replace", "write_file"):
-                                    first_edit = not has_made_edit
+                                if tc.function and tc.function.name in ("search_replace", "write_file"):
                                     has_made_edit = True
-                                    bash_count = 0  # Reset on successful edit
-                                    # Reset circuit breaker — the world changed after an edit,
-                                    # so previously-failing commands may now succeed
-                                    self._tool_call_history.clear()
-                                    self._consecutive_circuit_breaker_fires = 0
-                                    # Track blast radius
-                                    try:
-                                        edit_args = json.loads(tc.function.arguments or "{}")
-                                        edit_path = edit_args.get("file_path", edit_args.get("path", ""))
-                                        if edit_path and edit_path not in files_modified:
-                                            files_modified.append(edit_path)
-                                    except (json.JSONDecodeError, AttributeError):
-                                        edit_path = ""
-
-                                    # AUTO-FIX: Fix packaging issues the model gets wrong
-                                    if edit_path and edit_path.endswith(".py"):
-                                        self._auto_fix_package(edit_path)
-
-                                    # Auto-run diagnostics on edited Python files
-                                    if edit_path and edit_path.endswith(".py"):
-                                        try:
-                                            import asyncio
-                                            import subprocess
-                                            diag_result = subprocess.run(
-                                                ["python3", "-c", f"import ast; ast.parse(open('{edit_path}').read()); print('OK')"],
-                                                capture_output=True, text=True, timeout=5,
-                                            )
-                                            if diag_result.returncode != 0:
-                                                self._inject_system_note(
-                                                    f"SYNTAX ERROR in {edit_path}: {diag_result.stderr.strip()[:200]}. "
-                                                    f"Fix the syntax error before continuing."
-                                                )
-                                        except Exception:
-                                            pass
-
-                                    # After first edit: prompt to check related files
-                                    if first_edit and edit_path:
-                                        self._inject_system_note(
-                                            f"Good — you edited {edit_path}. Now check: "
-                                            f"does this bug have a RELATED file that also needs changes? "
-                                            f"Common patterns: if you edited a model, check the serializer/migration. "
-                                            f"If you edited a base class, check subclasses. "
-                                            f"If you edited a util, check callers. "
-                                            f"Use grep to search for imports of the function/class you changed."
-                                        )
-                                if tc.function.name == "read_file":
-                                    try:
-                                        args = json.loads(tc.function.arguments or "{}")
-                                        path = args.get("path", args.get("file_path", ""))
-                                        if path and path not in files_explored:
-                                            files_explored.append(path)
-                                    except (json.JSONDecodeError, AttributeError):
-                                        pass
-                                if tc.function.name in ("bash", "run_command"):
-                                    bash_count += 1
-
-                    # Track search_replace failures (called but error in result)
-                    for msg in reversed(self.messages[-3:]):
-                        if msg.role == Role.tool and msg.content:
-                            content = msg.content or ""
-                            if "search_replace" in content.lower() and "error" in content.lower():
-                                search_replace_failures += 1
-
-                # Blast radius check: warn when touching 5+ files
-                if len(files_modified) >= 5 and len(files_modified) % 5 == 0:
-                    self._inject_system_note(
-                        f"BLAST RADIUS WARNING: You have modified {len(files_modified)} files. "
-                        f"Files: {', '.join(files_modified[-5:])}. "
-                        f"This is a large change. Are you sure all these edits are needed? "
-                        f"Consider stopping to verify your approach."
-                    )
-
-                # Post-edit bash loop: model made edits but now loops on bash
-                # trying to test code that keeps failing
-                if has_made_edit and bash_count >= 3:
-                    # Count consecutive bash calls at end of tool history
-                    consecutive_bash = 0
-                    for tc_name in reversed(self._recent_tool_names()):
-                        if tc_name in ("bash", "run_command"):
-                            consecutive_bash += 1
-                        else:
-                            break
-                    if consecutive_bash >= 3:
-                        self._inject_system_note(
-                            "You have run 3+ bash commands in a row. "
-                            "If your project is WORKING, you are DONE — tell the user the project "
-                            "is complete and what commands they can use. "
-                            "If it is FAILING, STOP running bash and use read_file + search_replace "
-                            "to fix the code. Do NOT keep running the same test."
-                        )
-
-                # Detect bash file creation (touch, echo >, cat <<)
-                for msg in reversed(self.messages[-3:]):
-                    if msg.role == Role.assistant and msg.tool_calls:
-                        for tc in msg.tool_calls:
-                            if tc.function and tc.function.name in ("bash", "run_command"):
-                                cmd = ""
-                                try:
-                                    cmd = json.loads(tc.function.arguments or "{}").get("command", "")
-                                except (json.JSONDecodeError, AttributeError):
-                                    pass
-                                if any(kw in cmd for kw in ("touch ", "echo ", "cat <<", "printf ", "> ")):
-                                    self._inject_system_note(
-                                        f"Do NOT use bash to create files. Use write_file instead. "
-                                        f"bash touch/echo/cat does not create proper code files."
-                                    )
-
-                # Bash abuse detection: model uses bash instead of proper tools
-                if not has_made_edit and bash_count >= 3:
-                    if bash_count == 3:
-                        self._inject_system_note(
-                            "You have run 3 bash commands without creating or editing any files. "
-                            "STOP running bash. Start CREATING files with write_file or "
-                            "EDITING files with search_replace. bash does not create code."
-                        )
-                    elif bash_count == 6:
-                        self._inject_system_note(
-                            "WARNING: 6 bash commands, ZERO file edits. You are stuck in a loop. "
-                            "Your NEXT action MUST be write_file to create a file or "
-                            "search_replace to edit one. Do NOT run any more bash commands."
-                        )
-                    elif bash_count >= 10 and bash_count % 5 == 0:
-                        # Nudge every 5 bash calls, never stop
-                        self._inject_system_note(
-                            "You have run many bash commands. Consider using write_file "
-                            "or search_replace to create/edit files."
-                        )
-
-                # 3-Strike Rule: search_replace keeps failing
-                if search_replace_failures >= 3:
-                    if search_replace_failures == 3:
-                        self._inject_system_note(
-                            f"3-STRIKE RULE: Your search_replace has failed {search_replace_failures} times. "
-                            "STOP trying the same approach. "
-                            "Either: (1) use read_file to get the EXACT text first, "
-                            "(2) try a completely different file, or "
-                            "(3) ask the user for help with /consult."
-                        )
-                    elif search_replace_failures % 3 == 0:
-                        self._inject_system_note(
-                            f"STOP: {search_replace_failures} failed edits. You are stuck. Ask the user for help."
-                        )
-
-                # Context budget warning: after 7 tool turns without an edit,
-                # warn that context is being consumed without progress
-                if tool_turns == 7 and not has_made_edit and not context_summary_injected:
-                    context_summary_injected = True
-                    summary = (
-                        "CONTEXT BUDGET WARNING: You have used 7 tool calls without making an edit. "
-                        "Your context window is filling up — performance degrades as it fills. "
-                    )
-                    if files_explored:
-                        summary += "Files explored: " + ", ".join(files_explored[-5:]) + ". "
-                    summary += (
-                        "You MUST state your TARGET/FUNCTION/CAUSE/FIX now and use search_replace "
-                        "on your next turn. Do NOT continue exploring."
-                    )
-                    self._inject_system_note(summary)
+                                    break
 
                 should_break_loop = last_message.role != Role.tool
 

{drydock_cli-2.6.1 → drydock_cli-2.6.3}/drydock/core/llm/backend/generic.py

@@ -160,7 +160,7 @@ class OpenAIAdapter(APIAdapter):
         )
 
         # Enable thinking for models that support it (Gemma 4)
-        if thinking and thinking != "off":
+        if thinking and thinking not in ("off", ""):
             payload["chat_template_kwargs"] = {"enable_thinking": True}
 
         if enable_streaming:

{drydock_cli-2.6.1 → drydock_cli-2.6.3}/drydock/core/tools/builtins/ask_user_question.py

@@ -46,9 +46,8 @@ class Question(BaseModel):
 
 class AskUserQuestionArgs(BaseModel):
     questions: list[Question] = Field(
-        default_factory=lambda: [Question(text="What would you like to do?")],
+        default_factory=list,
         description="Questions to ask (1-4). Displayed as tabs if multiple.",
-        min_length=1,
         max_length=4,
     )
     content_preview: str | None = Field(

{drydock_cli-2.6.1 → drydock_cli-2.6.3}/drydock/core/tools/builtins/todo.py

@@ -4,7 +4,7 @@ from collections.abc import AsyncGenerator
 from enum import StrEnum, auto
 from typing import ClassVar
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
 
 from drydock.core.tools.base import (
     BaseTool,
@@ -37,6 +37,20 @@ class TodoItem(BaseModel):
     status: TodoStatus = TodoStatus.PENDING
     priority: TodoPriority = TodoPriority.MEDIUM
 
+    @field_validator("status", mode="before")
+    @classmethod
+    def clean_status(cls, v):
+        if isinstance(v, str):
+            return v.strip("'\"").lower()
+        return v
+
+    @field_validator("priority", mode="before")
+    @classmethod
+    def clean_priority(cls, v):
+        if isinstance(v, str):
+            return v.strip("'\"").lower()
+        return v
+
 
 class TodoArgs(BaseModel):
     action: str = Field(default="read", description="Either 'read' or 'write'")

{drydock_cli-2.6.1 → drydock_cli-2.6.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "2.6.1"
+version = "2.6.3"
 description = "Drydock — nautical CLI coding agent"
 readme = "README.md"
 requires-python = ">=3.12"

drydock_cli-2.6.3/tests/test_tool_args.py

@@ -0,0 +1,246 @@
+"""Test all tools accept the argument formats Gemma 4 actually sends.
+
+Gemma 4 quirks:
+- Wraps enum values in extra quotes: "'completed'" instead of "completed"
+- Sometimes omits required fields
+- Sometimes sends empty {} for all args
+- Sends file_path as "path" or vice versa
+- Sends content in wrong field for search_replace
+"""
+import json
+import pytest
+from pathlib import Path
+from unittest.mock import MagicMock
+
+
+def try_validate(args_class, data: dict) -> tuple[bool, str]:
+    """Try to validate args, return (success, error_message)."""
+    try:
+        args_class.model_validate(data)
+        return True, ""
+    except Exception as e:
+        return False, str(e)[:200]
+
+
+class TestTodoArgs:
+    """Todo tool argument validation."""
+
+    def setup_method(self):
+        from drydock.core.tools.builtins.todo import TodoArgs, TodoItem
+        self.TodoArgs = TodoArgs
+        self.TodoItem = TodoItem
+
+    def test_empty_args_has_default(self):
+        """Empty {} should work — action defaults to 'read'."""
+        ok, err = try_validate(self.TodoArgs, {})
+        assert ok, f"Empty args failed: {err}"
+
+    def test_quoted_enum_status(self):
+        """Gemma 4 sends \"'completed'\" with extra quotes."""
+        ok, err = try_validate(self.TodoItem, {
+            "id": "1", "content": "test", "status": "'completed'", "priority": "high"
+        })
+        assert ok, f"Quoted status failed: {err}"
+
+    def test_quoted_enum_priority(self):
+        """Gemma 4 sends \"'high'\" with extra quotes."""
+        ok, err = try_validate(self.TodoItem, {
+            "id": "1", "content": "test", "status": "pending", "priority": "'high'"
+        })
+        assert ok, f"Quoted priority failed: {err}"
+
+    def test_uppercase_enum(self):
+        """Model might send COMPLETED instead of completed."""
+        ok, err = try_validate(self.TodoItem, {
+            "id": "1", "content": "test", "status": "COMPLETED", "priority": "HIGH"
+        })
+        assert ok, f"Uppercase enum failed: {err}"
+
+
+class TestWriteFileArgs:
+    """Write file tool argument validation."""
+
+    def setup_method(self):
+        from drydock.core.tools.builtins.write_file import WriteFileArgs
+        self.WriteFileArgs = WriteFileArgs
+
+    def test_normal_args(self):
+        ok, err = try_validate(self.WriteFileArgs, {
+            "path": "test.py", "content": "print('hello')"
+        })
+        assert ok, f"Normal args failed: {err}"
+
+    def test_overwrite_defaults_true(self):
+        """Overwrite should default to True."""
+        args = self.WriteFileArgs.model_validate({"path": "test.py", "content": "x"})
+        assert args.overwrite is True
+
+    def test_empty_content(self):
+        """Empty content should be accepted (for __init__.py)."""
+        ok, err = try_validate(self.WriteFileArgs, {
+            "path": "test.py", "content": ""
+        })
+        assert ok, f"Empty content failed: {err}"
+
+
+class TestSearchReplaceArgs:
+    """Search replace tool argument validation."""
+
+    def setup_method(self):
+        from drydock.core.tools.builtins.search_replace import SearchReplaceArgs
+        self.SearchReplaceArgs = SearchReplaceArgs
+
+    def test_normal_args(self):
+        ok, err = try_validate(self.SearchReplaceArgs, {
+            "file_path": "test.py",
+            "content": "<<<<<<< SEARCH\nold\n=======\nnew\n>>>>>>> REPLACE"
+        })
+        assert ok, f"Normal args failed: {err}"
+
+    def test_missing_file_path_has_default(self):
+        """file_path should default to empty string, not crash."""
+        ok, err = try_validate(self.SearchReplaceArgs, {
+            "content": "<<<<<<< SEARCH\nold\n=======\nnew\n>>>>>>> REPLACE"
+        })
+        assert ok, f"Missing file_path failed: {err}"
+
+    def test_old_new_string_direct(self):
+        """Gemma 4 sometimes sends old_string/new_string directly."""
+        ok, err = try_validate(self.SearchReplaceArgs, {
+            "file_path": "test.py",
+            "old_string": "old text",
+            "new_string": "new text"
+        })
+        assert ok, f"Direct old/new string failed: {err}"
+
+    def test_empty_args(self):
+        """Empty args should not crash."""
+        ok, err = try_validate(self.SearchReplaceArgs, {})
+        assert ok, f"Empty args failed: {err}"
+
+
+class TestAskUserQuestionArgs:
+    """Ask user question tool argument validation."""
+
+    def setup_method(self):
+        from drydock.core.tools.builtins.ask_user_question import AskUserQuestionArgs
+        self.AskUserQuestionArgs = AskUserQuestionArgs
+
+    def test_empty_args_has_default(self):
+        """Empty {} should work — questions has a default."""
+        ok, err = try_validate(self.AskUserQuestionArgs, {})
+        assert ok, f"Empty args failed: {err}"
+
+
+class TestReadFileArgs:
+    """Read file tool argument validation."""
+
+    def setup_method(self):
+        from drydock.core.tools.builtins.read_file import ReadFileArgs
+        self.ReadFileArgs = ReadFileArgs
+
+    def test_path_field(self):
+        ok, err = try_validate(self.ReadFileArgs, {"path": "test.py"})
+        assert ok, f"Path field failed: {err}"
+
+    def test_with_offset_limit(self):
+        ok, err = try_validate(self.ReadFileArgs, {
+            "path": "test.py", "offset": 10, "limit": 50
+        })
+        assert ok, f"Offset/limit failed: {err}"
+
+
+class TestBashArgs:
+    """Bash tool argument validation."""
+
+    def setup_method(self):
+        from drydock.core.tools.builtins.bash import BashArgs
+        self.BashArgs = BashArgs
+
+    def test_command_field(self):
+        ok, err = try_validate(self.BashArgs, {"command": "ls -la"})
+        assert ok, f"Command field failed: {err}"
+
+    def test_with_timeout(self):
+        ok, err = try_validate(self.BashArgs, {"command": "sleep 1", "timeout": 5})
+        assert ok, f"Timeout failed: {err}"
+
+
+class TestGrepArgs:
+    """Grep tool argument validation."""
+
+    def setup_method(self):
+        from drydock.core.tools.builtins.grep import GrepArgs
+        self.GrepArgs = GrepArgs
+
+    def test_pattern_only(self):
+        ok, err = try_validate(self.GrepArgs, {"pattern": "def main"})
+        assert ok, f"Pattern only failed: {err}"
+
+    def test_with_path(self):
+        ok, err = try_validate(self.GrepArgs, {"pattern": "import", "path": "."})
+        assert ok, f"With path failed: {err}"
+
+
+class TestGlobArgs:
+    """Glob tool argument validation."""
+
+    def setup_method(self):
+        from drydock.core.tools.builtins.glob_tool import GlobArgs
+        self.GlobArgs = GlobArgs
+
+    def test_pattern(self):
+        ok, err = try_validate(self.GlobArgs, {"pattern": "*.py"})
+        assert ok, f"Pattern failed: {err}"
+
+
+class TestTaskCreateArgs:
+    """Task create tool argument validation."""
+
+    def setup_method(self):
+        from drydock.core.tools.builtins.task_manager import TaskCreateArgs
+        self.TaskCreateArgs = TaskCreateArgs
+
+    def test_normal(self):
+        ok, err = try_validate(self.TaskCreateArgs, {"title": "Build the app"})
+        assert ok, f"Normal args failed: {err}"
+
+    def test_with_description(self):
+        ok, err = try_validate(self.TaskCreateArgs, {
+            "title": "Build the app", "description": "Create all files"
+        })
+        assert ok, f"With description failed: {err}"
+
+
+class TestSearchReplaceBlockParsing:
+    """Test that search_replace parses various block formats."""
+
+    def setup_method(self):
+        from drydock.core.tools.builtins.search_replace import SearchReplace
+        self.parse = SearchReplace._parse_search_replace_blocks
+
+    def test_standard_format(self):
+        blocks = self.parse("<<<<<<< SEARCH\nold text\n=======\nnew text\n>>>>>>> REPLACE")
+        assert len(blocks) == 1
+        assert blocks[0].search == "old text"
+        assert blocks[0].replace == "new text"
+
+    def test_repeated_search_word(self):
+        """Gemma 4 sometimes repeats: SEARCH SEARCH SEARCH."""
+        blocks = self.parse("<<<<<<<<< SEARCH SEARCH SEARCH\nold\n=======\nnew\n>>>>>>>>> REPLACE REPLACE")
+        assert len(blocks) == 1
+
+    def test_json_format(self):
+        """Gemma 4 sometimes sends JSON."""
+        blocks = self.parse('{"old_string": "old", "new_string": "new"}')
+        assert len(blocks) == 1
+        assert blocks[0].search == "old"
+
+    def test_separator_format(self):
+        """Simple ======= separator."""
+        blocks = self.parse("old text\n=======\nnew text")
+        assert len(blocks) == 1
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])