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

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

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

@@ -790,81 +790,21 @@ class AgentLoop:
                         continue
                     # After 3 empty responses, let it exit
 
-                # If model gives text without tool calls and hasn't edited anything,
-                # nudge it to make an edit instead of just describing what to do.
-                # Never let the agent exit without at least attempting an edit.
-                if should_break_loop and not has_made_edit and tool_turns >= 1:
-                    text_without_action += 1
-                    # Always continue — don't let the agent exit without editing
-                    should_break_loop = False
-
-                    # Detect model claiming task is done without having edited anything
-                    last_text_lower = (last_message.content or "").lower()
-                    task_complete_phrases = [
-                        "task completed", "task complete", "task is complete",
-                        "task is done", "task has been completed",
-                        "changes have been applied", "fix has been applied",
-                        "the fix is complete", "issue is resolved",
-                    ]
-                    claims_complete = any(p in last_text_lower for p in task_complete_phrases)
-
-                    if claims_complete:
-                        nudge_text = (
-                            "You said the task is complete but NO code was actually changed. "
-                            "Your search_replace call either failed or was never made. "
-                            "Use read_file to read the target file, then use search_replace "
-                            "to make your edit. Do NOT say the task is done until search_replace succeeds."
-                        )
-                    elif text_without_action == 1:
-                        last_text = (last_message.content or "").lower()
-                        # Detect model asking for confirmation instead of acting
-                        is_asking = any(kw in last_text for kw in (
-                            "standing by", "waiting for", "please provide",
-                            "what would you like", "how can i help",
-                            "what should i", "do you want me to",
-                            "ready to begin", "i will start",
-                            "shall i", "would you like me to",
-                            "let me know", "please confirm",
-                            "i am ready", "ready to proceed",
-                        ))
-                        if is_asking:
-                            nudge_text = (
-                                "DO NOT ask for confirmation. Act NOW. "
-                                "If there is a PRD.md, implement it with write_file. "
-                                "If there is code, read it with read_file and fix bugs with search_replace. "
-                                "Call a tool on your next response."
-                            )
-                        elif "TARGET:" in last_text.upper() or "FILE:" in last_text.upper():
-                            nudge_text = (
-                                "Good — you identified the target. Now use read_file then search_replace."
-                            )
-                        else:
-                            nudge_text = (
-                                "You responded with text but did not call any tools. "
-                                "Call write_file, read_file, or search_replace NOW."
-                            )
-                    elif text_without_action == 2:
-                        nudge_text = (
-                            "STOP describing the fix. You MUST call search_replace on your NEXT response. "
-                            "No more text-only responses. Act NOW."
-                        )
-                    elif text_without_action <= 5:
-                        nudge_text = (
-                            f"WARNING ({text_without_action} text responses without editing): "
-                            "You MUST call search_replace or read_file immediately. "
-                            "Make your best fix attempt RIGHT NOW even if you are unsure. "
-                            "Pick the most likely file and function, and make a minimal edit."
-                        )
-                    else:
-                        # Keep nudging — never give up
-                        nudge_text = (
-                            "You MUST call a tool. Use grep to find the file, "
-                            "read_file to read it, then search_replace to fix."
+                # Text response without edits — this is FINE for questions,
+                # explanations, running code, etc. Only nudge if the model
+                # is clearly asking for permission instead of acting.
+                if should_break_loop and not has_made_edit:
+                    last_text = (last_message.content or "").lower()
+                    is_asking = any(kw in last_text for kw in (
+                        "shall i", "would you like me to",
+                        "ready to begin", "please confirm",
+                    ))
+                    if is_asking and tool_turns == 0:
+                        # Model asked without doing anything — nudge once
+                        should_break_loop = False
+                        self._inject_system_note(
+                            "Act immediately. Do not ask for confirmation."
                         )
-                    if nudge_text:
-                        # Use _inject_system_note (appends to last tool/user message)
-                        # User messages cause 'tool after user' ordering violations
-                        self._inject_system_note(nudge_text)
                         logger.info("Model gave text without editing — nudging (attempt %d)", text_without_action)
 
                 # If model has been investigating for too long without making an edit,
@@ -949,6 +889,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.6/drydock/core/session_checker.py

@@ -0,0 +1,163 @@
+"""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 — only flag if the user explicitly asked to build/fix/create something
+    # Questions, exploration, and running code don't need edits
+    if not has_made_edit and len(messages) > 10:
+        user_msgs = [str(getattr(m, 'content', '') or '').lower() for m in messages
+                     if hasattr(m, 'role') and str(getattr(m, 'role', '')) == 'user']
+        build_words = ["build", "create", "fix", "implement", "write", "add", "modify", "update", "edit"]
+        user_asked_for_edit = any(
+            any(w in msg for w in build_words)
+            for msg in user_msgs
+        )
+        if user_asked_for_edit:
+            issues.append(SessionIssue(
+                "info", "no_edits",
+                "No file changes were made — the model may not have completed the task"
+            ))
+
+    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.6}/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,21 @@ 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)
+            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.6}/pyproject.toml

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