drydock-cli 2.5.4__tar.gz → 2.5.5__tar.gz

{drydock_cli-2.5.4 → drydock_cli-2.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.5.4
+Version: 2.5.5
 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.5.4 → drydock_cli-2.5.5}/drydock/core/agent_loop.py

@@ -949,6 +949,20 @@ class AgentLoop:
         finally:
             await self._save_messages()
 
+            # Post-session quality check
+            try:
+                from drydock.core.session_checker import check_session, format_issues
+                issues = check_session(
+                    list(self.messages),
+                    has_made_edit=has_made_edit,
+                )
+                if issues:
+                    report = format_issues(issues)
+                    if report:
+                        yield AssistantEvent(content=report)
+            except Exception:
+                pass  # Non-critical — don't crash on checker errors
+
     async def _perform_llm_turn(self) -> AsyncGenerator[BaseEvent, None]:
         if self.enable_streaming:
             async for event in self._stream_assistant_events():

drydock_cli-2.5.5/drydock/core/session_checker.py

@@ -0,0 +1,160 @@
+"""Post-session quality checker for DryDock TUI.
+
+After each agent session, scans the conversation for common issues
+and reports them to the user. This catches problems that the model
+doesn't self-detect.
+"""
+from __future__ import annotations
+
+import json
+import re
+from collections import Counter
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from drydock.core.types import LLMMessage, Role
+
+
+class SessionIssue:
+    def __init__(self, severity: str, category: str, message: str):
+        self.severity = severity  # "error", "warning", "info"
+        self.category = category
+        self.message = message
+
+    def __str__(self):
+        icons = {"error": "✗", "warning": "⚠", "info": "ℹ"}
+        return f"{icons.get(self.severity, '?')} [{self.category}] {self.message}"
+
+
+def check_session(messages: list, has_made_edit: bool = False) -> list[SessionIssue]:
+    """Check a completed session for quality issues.
+
+    Returns a list of issues found. Empty list = clean session.
+    """
+    issues = []
+
+    if not messages:
+        return issues
+
+    # 1. Unknown tool errors
+    unknown_tools = []
+    for msg in messages:
+        content = str(getattr(msg, 'content', '') or '')
+        if "Unknown tool" in content:
+            match = re.search(r"Unknown tool '(\w+)'", content)
+            if match:
+                unknown_tools.append(match.group(1))
+    if unknown_tools:
+        tools = ', '.join(set(unknown_tools))
+        issues.append(SessionIssue(
+            "warning", "tool_error",
+            f"Model tried to call unavailable tools: {tools}"
+        ))
+
+    # 2. search_replace errors
+    sr_errors = 0
+    for msg in messages:
+        content = str(getattr(msg, 'content', '') or '')
+        if "search_replace" in content and ("error" in content.lower() or "not found" in content.lower()):
+            sr_errors += 1
+    if sr_errors > 2:
+        issues.append(SessionIssue(
+            "warning", "edit_failures",
+            f"search_replace failed {sr_errors} times — model may not have applied intended edits"
+        ))
+
+    # 3. Same file written too many times
+    write_paths = []
+    for msg in messages:
+        if hasattr(msg, 'tool_calls') and msg.tool_calls:
+            for tc in (msg.tool_calls or []):
+                if hasattr(tc, 'function') and tc.function:
+                    if tc.function.name == "write_file":
+                        try:
+                            args = json.loads(tc.function.arguments or "{}")
+                            path = args.get("path", "")
+                            if path:
+                                write_paths.append(path)
+                        except (json.JSONDecodeError, AttributeError):
+                            pass
+    if write_paths:
+        counts = Counter(write_paths)
+        for path, count in counts.most_common(3):
+            if count > 3:
+                issues.append(SessionIssue(
+                    "warning", "write_loop",
+                    f"'{path}' was written {count} times — possible loop"
+                ))
+
+    # 4. Text repetition in model responses
+    for msg in messages:
+        content = str(getattr(msg, 'content', '') or '')
+        if len(content) > 300:
+            sentences = [s.strip() for s in content.split('.') if len(s.strip()) > 30]
+            if sentences:
+                counts = Counter(sentences)
+                most, count = counts.most_common(1)[0]
+                if count >= 3:
+                    issues.append(SessionIssue(
+                        "warning", "text_loop",
+                        f"Model repeated the same sentence {count} times"
+                    ))
+                    break  # Only report once
+
+    # 5. "Please let me know" / asking for confirmation
+    ask_count = 0
+    for msg in messages:
+        content = str(getattr(msg, 'content', '') or '').lower()
+        if any(phrase in content for phrase in [
+            "please let me know", "shall i", "would you like",
+            "ready to begin", "please provide", "let me know if",
+        ]):
+            ask_count += 1
+    if ask_count > 1:
+        issues.append(SessionIssue(
+            "info", "confirmation_asking",
+            f"Model asked for confirmation {ask_count} times instead of acting"
+        ))
+
+    # 6. API errors
+    api_errors = 0
+    for msg in messages:
+        content = str(getattr(msg, 'content', '') or '')
+        if "API error" in content or "400 Bad Request" in content:
+            api_errors += 1
+    if api_errors > 0:
+        issues.append(SessionIssue(
+            "error", "api_errors",
+            f"{api_errors} API errors occurred during the session"
+        ))
+
+    # 7. No edits made despite having a task
+    if not has_made_edit and len(messages) > 5:
+        has_user_task = any(
+            hasattr(msg, 'role') and str(getattr(msg, 'role', '')) == 'user'
+            and len(str(getattr(msg, 'content', '') or '')) > 20
+            for msg in messages
+        )
+        if has_user_task:
+            issues.append(SessionIssue(
+                "warning", "no_edits",
+                "Session ended without making any file changes"
+            ))
+
+    return issues
+
+
+def format_issues(issues: list[SessionIssue]) -> str:
+    """Format issues for display in the TUI."""
+    if not issues:
+        return ""
+
+    errors = [i for i in issues if i.severity == "error"]
+    warnings = [i for i in issues if i.severity == "warning"]
+    infos = [i for i in issues if i.severity == "info"]
+
+    lines = ["", "Session Quality Check:"]
+    for issue in errors + warnings + infos:
+        lines.append(f"  {issue}")
+
+    return "\n".join(lines)

{drydock_cli-2.5.4 → drydock_cli-2.5.5}/drydock/core/tools/builtins/search_replace.py

@@ -53,8 +53,11 @@ class BlockApplyResult(NamedTuple):
 
 
 class SearchReplaceArgs(BaseModel):
-    file_path: str
-    content: str
+    file_path: str = Field(default="", description="Path to the file to edit")
+    content: str = Field(default="", description="SEARCH/REPLACE blocks or JSON with old_string/new_string")
+    # Gemma 4 sometimes sends these directly instead of in content
+    old_string: str | None = Field(default=None, description="Text to find (alternative to content blocks)")
+    new_string: str | None = Field(default=None, description="Replacement text (alternative to content blocks)")
 
 
 class SearchReplaceResult(BaseModel):
@@ -178,8 +181,22 @@ class SearchReplace(
         file_path_str = args.file_path.strip()
         content = args.content.strip()
 
+        # Handle direct old_string/new_string args (Gemma 4 sometimes sends these)
+        if not content and args.old_string is not None and args.new_string is not None:
+            content = f"<<<<<<< SEARCH\n{args.old_string}\n=======\n{args.new_string}\n>>>>>>> REPLACE"
+
+        # Try to extract file_path from content if missing
+        if not file_path_str and content:
+            # Look for file path in the content (common when model puts everything in content)
+            import re
+            path_match = re.search(r'(?:file[_\s]?path|path|file)[\s:="\']+([^\s"\']+\.py)', content[:200], re.IGNORECASE)
+            if path_match:
+                file_path_str = path_match.group(1)
+
         if not file_path_str:
-            raise ToolError("File path cannot be empty")
+            raise ToolError(
+                "File path is required. Use: search_replace(file_path='path/to/file.py', content='...')"
+            )
 
         if len(content) > self.config.max_content_size:
             raise ToolError(

{drydock_cli-2.5.4 → drydock_cli-2.5.5}/pyproject.toml

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