drydock-cli 1.9.1__tar.gz → 1.9.2__tar.gz

{drydock_cli-1.9.1 → drydock_cli-1.9.2}/PKG-INFO

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

{drydock_cli-1.9.1 → drydock_cli-1.9.2}/drydock/core/agent_loop.py

@@ -531,10 +531,8 @@ class AgentLoop:
                 if auto_context:
                     self._inject_system_note(auto_context)
         else:
-            # Normal flow: inject context for non-build tasks
-            auto_context = self._build_auto_context(user_msg)
-            if auto_context:
-                self._inject_system_note(auto_context)
+            # Smart task routing: auto-explore + skill injection
+            await self._auto_route_task(user_msg)
 
         try:
             should_break_loop = False
@@ -1737,6 +1735,94 @@ class AgentLoop:
 
         return None
 
+    async def _auto_route_task(self, user_msg: str) -> None:
+        """Auto-explore the project and inject skill instructions.
+
+        Instead of hoping the model calls task(agent='explore'), we do
+        the exploration ourselves and inject the results + relevant skill.
+        """
+        msg_lower = user_msg.lower()
+        parts = []
+
+        # 1. Auto-explore: if project has files, read key ones
+        try:
+            cwd = Path.cwd()
+            py_files = sorted(
+                f for f in cwd.rglob("*.py")
+                if ".logs" not in str(f) and ".venv" not in str(f)
+                and "__pycache__" not in str(f)
+            )
+
+            if len(py_files) >= 3:
+                # List all files
+                listing = "\n".join(f"  {f.relative_to(cwd)}" for f in py_files[:30])
+                parts.append(f"PROJECT FILES ({len(py_files)} Python files):\n{listing}")
+
+                # Auto-read key files (entry points, __init__, small files)
+                files_read = 0
+                for f in py_files[:15]:
+                    if files_read >= 5:
+                        break
+                    if f.stat().st_size > 10000:
+                        continue  # Skip large files
+                    if f.name in ("__init__.py", "__main__.py"):
+                        continue  # Skip boilerplate
+                    try:
+                        content = f.read_text()[:2000]
+                        rel = f.relative_to(cwd)
+                        # Extract just function/class signatures
+                        import ast
+                        tree = ast.parse(content)
+                        sigs = []
+                        for node in ast.walk(tree):
+                            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                                args = ", ".join(a.arg for a in node.args.args)
+                                sigs.append(f"  def {node.name}({args}) [line {node.lineno}]")
+                            elif isinstance(node, ast.ClassDef):
+                                sigs.append(f"  class {node.name} [line {node.lineno}]")
+                        if sigs:
+                            parts.append(f"{rel}:\n" + "\n".join(sigs[:10]))
+                            files_read += 1
+                    except Exception:
+                        pass
+        except Exception:
+            pass
+
+        # 2. Detect task type and inject skill content
+        skill_name = None
+        if any(kw in msg_lower for kw in ("review", "audit", "check the code", "code quality")):
+            skill_name = "review"
+        elif any(kw in msg_lower for kw in ("investigate", "debug", "why does", "why is", "broken", "failing")):
+            skill_name = "investigate"
+        elif any(kw in msg_lower for kw in ("ship", "commit and push", "create a pr", "open pr", "deploy")):
+            skill_name = "ship"
+        elif any(kw in msg_lower for kw in ("simplify", "clean up", "refactor", "reduce complexity")):
+            skill_name = "simplify"
+
+        if skill_name:
+            skill_info = self.skill_manager.get_skill(skill_name)
+            if skill_info and skill_info.skill_path:
+                try:
+                    content = skill_info.skill_path.read_text(encoding="utf-8")
+                    if content.startswith("---"):
+                        end = content.find("---", 3)
+                        if end > 0:
+                            content = content[end + 3:].strip()
+                    parts.append(f"FOLLOW THIS WORKFLOW ({skill_name} skill):\n{content[:2000]}")
+                except Exception:
+                    pass
+
+        # 3. Also list non-Python files of interest
+        try:
+            for pattern in ("*.md", "*.txt", "*.json", "*.yaml", "*.yml", "*.toml", "*.csv"):
+                for f in sorted(Path.cwd().glob(pattern))[:3]:
+                    parts.append(f"  {f.name} ({f.stat().st_size} bytes)")
+        except Exception:
+            pass
+
+        if parts:
+            self._inject_system_note("\n\n".join(parts))
+
     def _is_build_task(self, user_msg: str) -> bool:
         """Detect if a user message is a complex build task that needs orchestration."""
         msg_lower = user_msg.lower()

{drydock_cli-1.9.1 → drydock_cli-1.9.2}/pyproject.toml

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

{drydock_cli-1.9.1 → drydock_cli-1.9.2}/tests/test_drydock_tasks.py

@@ -388,11 +388,10 @@ class TestDeviationHandling:
 # ============================================================================
 
 class TestCircuitBreaker:
-    """Prevents exact duplicate tool calls."""
+    """Circuit breaker only blocks commands that FAILED 3+ times."""
 
-    def test_circuit_breaker_blocks_after_threshold(self):
-        """Non-readonly successful bash calls block after 4 repeats."""
-        import asyncio
+    def test_successful_commands_never_blocked(self):
+        """Successful commands are never blocked, no matter how many repeats."""
         from drydock.core.agent_loop import AgentLoop
         from drydock.core.types import MessageList
         from types import SimpleNamespace
@@ -403,18 +402,14 @@ class TestCircuitBreaker:
 
         tc = SimpleNamespace(tool_name="bash", args_dict={"command": "ls -ltr"})
 
-        # Non-readonly bash: success threshold is 4
-        for _ in range(4):
+        for _ in range(10):
             assert al._circuit_breaker_check(tc) is None
             al._circuit_breaker_record(tc, "file1.py\nfile2.py")
 
-        result = al._circuit_breaker_check(tc)
-        assert result is not None
-        assert "CIRCUIT BREAKER" in result
+        assert al._circuit_breaker_check(tc) is None
 
-    def test_circuit_breaker_blocks_failed_after_2(self):
-        """Failed tool calls still block after 2 repeats."""
-        import asyncio
+    def test_circuit_breaker_blocks_failed_after_3(self):
+        """Failed tool calls block after 3 repeats."""
         from drydock.core.agent_loop import AgentLoop
         from drydock.core.types import MessageList
         from types import SimpleNamespace
@@ -425,17 +420,18 @@ class TestCircuitBreaker:
 
         tc = SimpleNamespace(tool_name="bash", args_dict={"command": "bad_cmd"})
 
+        al._circuit_breaker_record(tc, "FAILED: command not found")
+        assert al._circuit_breaker_check(tc) is None
         al._circuit_breaker_record(tc, "FAILED: command not found")
         assert al._circuit_breaker_check(tc) is None
         al._circuit_breaker_record(tc, "FAILED: command not found")
 
         result = al._circuit_breaker_check(tc)
         assert result is not None
-        assert "CIRCUIT BREAKER" in result
+        assert "failed" in result
 
     def test_different_args_not_blocked(self):
-        """Different arguments should not be blocked even if one arg set is."""
-        import asyncio
+        """Different arguments should not be blocked even if one arg set failed 3x."""
         from drydock.core.agent_loop import AgentLoop
         from drydock.core.types import MessageList
         from types import SimpleNamespace
@@ -444,12 +440,11 @@ class TestCircuitBreaker:
         al.messages = MessageList()
         al._tool_call_history = {}
 
-        tc1 = SimpleNamespace(tool_name="bash", args_dict={"command": "ls -ltr"})
+        tc1 = SimpleNamespace(tool_name="bash", args_dict={"command": "bad_cmd"})
         tc2 = SimpleNamespace(tool_name="bash", args_dict={"command": "ls -la"})
 
-        # Non-readonly bash needs 4 repeats to block
-        for _ in range(4):
-            al._circuit_breaker_record(tc1, "result1")
+        for _ in range(3):
+            al._circuit_breaker_record(tc1, "FAILED: command not found")
         assert al._circuit_breaker_check(tc1) is not None
         assert al._circuit_breaker_check(tc2) is None
 

{drydock_cli-1.9.1 → drydock_cli-1.9.2}/tests/test_loop_detection.py

@@ -2,8 +2,8 @@
 
 Simulates real message histories that trigger each loop detection mechanism.
 These test the exact scenarios users report:
-- Running same command 4+ times (circuit breaker for bash, 6 for readonly)
-- Exact same tool call repeated 4+ times (Check 1: REPEAT_WARNING)
+- Same command FAILING 3+ times (circuit breaker — only blocks failed commands)
+- Exact same tool call repeated N+ times (Check 1: REPEAT_WARNING)
 - 5 consecutive bash calls with different args (Check 2: same-tool)
 - Reading the same file 5+ times with different offsets (Check 3: same-file)
 - Alternating grep->read_file->grep->read_file (Check 4: alternating)
@@ -55,7 +55,7 @@ def _add_tool_call(al: AgentLoop, tool_name: str, arguments: str = "{}") -> None
 # ============================================================================
 
 class TestCircuitBreaker:
-    """Circuit breaker: blocks failed commands after 2, successful after 4 (6 for readonly)."""
+    """Circuit breaker: only blocks commands that FAILED 3+ times."""
 
     def test_first_call_allowed(self):
         al = _make_agent()
@@ -68,86 +68,84 @@ class TestCircuitBreaker:
         al._circuit_breaker_record(tc, "file1.py\nfile2.py")
         assert al._circuit_breaker_check(tc) is None
 
-    def test_failed_blocked_after_2(self):
-        """Failed commands blocked after 2 repeats."""
+    def test_failed_blocked_after_3(self):
+        """Failed commands blocked after 3 repeats."""
         al = _make_agent()
         tc = SimpleNamespace(tool_name="bash", args_dict={"command":"bad_cmd"})
-        al._circuit_breaker_record(tc, "FAILED: command not found")
-        al._circuit_breaker_record(tc, "FAILED: command not found")
+        for _ in range(3):
+            al._circuit_breaker_record(tc, "FAILED: command not found")
         result = al._circuit_breaker_check(tc)
         assert result is not None
-        assert "CIRCUIT BREAKER" in result
+        assert "failed" in result
 
-    def test_successful_blocked_after_4(self):
-        """Successful non-readonly commands blocked after 4 repeats."""
+    def test_failed_2_not_blocked(self):
+        """Failed commands with only 2 repeats are not blocked yet."""
         al = _make_agent()
-        tc = SimpleNamespace(tool_name="bash", args_dict={"command":"python3 app.py"})
-        for _ in range(4):
-            al._circuit_breaker_record(tc, "output ok")
-        result = al._circuit_breaker_check(tc)
-        assert result is not None
-        assert "CIRCUIT BREAKER" in result
+        tc = SimpleNamespace(tool_name="bash", args_dict={"command":"bad_cmd"})
+        al._circuit_breaker_record(tc, "FAILED: command not found")
+        al._circuit_breaker_record(tc, "FAILED: command not found")
+        assert al._circuit_breaker_check(tc) is None
 
-    def test_successful_3_not_blocked(self):
-        """3 successful non-readonly calls still allowed."""
+    def test_successful_never_blocked(self):
+        """Successful commands are never blocked regardless of repeat count."""
         al = _make_agent()
         tc = SimpleNamespace(tool_name="bash", args_dict={"command":"python3 app.py"})
-        for _ in range(3):
+        for _ in range(10):
             al._circuit_breaker_record(tc, "output ok")
         assert al._circuit_breaker_check(tc) is None
 
-    def test_readonly_higher_threshold(self):
-        """Read-only tools (grep) get higher threshold (6)."""
+    def test_successful_readonly_never_blocked(self):
+        """Read-only successful tools are never blocked."""
         al = _make_agent()
         tc = SimpleNamespace(tool_name="grep", args_dict={"pattern":"foo"})
-        for _ in range(5):
+        for _ in range(10):
             al._circuit_breaker_record(tc, "match.py:10:foo")
-        assert al._circuit_breaker_check(tc) is None  # 5 is OK for readonly
-        al._circuit_breaker_record(tc, "match.py:10:foo")
-        result = al._circuit_breaker_check(tc)
-        assert result is not None  # 6 triggers block
+        assert al._circuit_breaker_check(tc) is None
 
-    def test_blocked_message_contains_previous_result(self):
+    def test_blocked_message_suggests_different_approach(self):
         al = _make_agent()
         tc = SimpleNamespace(tool_name="bash", args_dict={"command":"python3 run.py"})
-        for _ in range(4):
-            al._circuit_breaker_record(tc, "important_file.py")
+        for _ in range(3):
+            al._circuit_breaker_record(tc, "FAILED: module not found")
         result = al._circuit_breaker_check(tc)
-        assert "important_file.py" in result
+        assert result is not None
+        assert "DIFFERENT" in result or "different" in result
 
-    def test_blocked_message_contains_alternatives(self):
+    def test_blocked_message_mentions_failure_count(self):
         al = _make_agent()
         tc = SimpleNamespace(tool_name="bash", args_dict={"command":"python3 run.py"})
-        for _ in range(4):
-            al._circuit_breaker_record(tc, "output")
+        for _ in range(3):
+            al._circuit_breaker_record(tc, "FAILED: error")
         result = al._circuit_breaker_check(tc)
-        assert "DIFFERENT" in result or "different" in result
+        assert "3" in result
 
     def test_different_args_not_blocked(self):
         al = _make_agent()
-        tc1 = SimpleNamespace(tool_name="bash", args_dict={"command":"ls -ltr"})
+        tc1 = SimpleNamespace(tool_name="bash", args_dict={"command":"bad_cmd"})
         tc2 = SimpleNamespace(tool_name="bash", args_dict={"command":"ls -la"})
-        for _ in range(4):
-            al._circuit_breaker_record(tc1, "r1")
-        assert al._circuit_breaker_check(tc1) is not None  # Blocked
+        for _ in range(3):
+            al._circuit_breaker_record(tc1, "FAILED: not found")
+        assert al._circuit_breaker_check(tc1) is not None  # Blocked (failed 3x)
         assert al._circuit_breaker_check(tc2) is None       # Not blocked
 
     def test_different_tools_not_blocked(self):
         al = _make_agent()
-        tc1 = SimpleNamespace(tool_name="bash", args_dict={"command":"ls"})
+        tc1 = SimpleNamespace(tool_name="bash", args_dict={"command":"bad_cmd"})
         tc2 = SimpleNamespace(tool_name="grep", args_dict={"pattern":"foo"})
-        for _ in range(4):
-            al._circuit_breaker_record(tc1, "r1")
+        for _ in range(3):
+            al._circuit_breaker_record(tc1, "FAILED: not found")
         assert al._circuit_breaker_check(tc1) is not None
         assert al._circuit_breaker_check(tc2) is None
 
-    def test_already_attempted_summary(self):
+    def test_failed_then_success_not_blocked(self):
+        """If a command fails then succeeds, it should not be blocked."""
         al = _make_agent()
-        tc = SimpleNamespace(tool_name="bash", args_dict={"command":"ls"})
-        for _ in range(4):
-            al._circuit_breaker_record(tc, "output1")
-        result = al._circuit_breaker_check(tc)
-        assert "ALREADY ATTEMPTED" in result
+        tc = SimpleNamespace(tool_name="bash", args_dict={"command":"python3 run.py"})
+        al._circuit_breaker_record(tc, "FAILED: error")
+        al._circuit_breaker_record(tc, "FAILED: error")
+        # Now it succeeds — last_result no longer starts with FAILED:
+        al._circuit_breaker_record(tc, "output ok")
+        assert al._circuit_breaker_check(tc) is None
 
 
 # ============================================================================
@@ -355,16 +353,16 @@ class TestRealWorldLoops:
     """Simulate actual user-reported looping scenarios."""
 
     def test_ls_ltr_loop(self):
-        """User reports: `ls -ltr` runs 5+ times. Circuit breaker stops at 4."""
+        """Successful `ls -ltr` is never blocked by circuit breaker.
+        Loop detection (_check_tool_call_repetition) handles this instead."""
         al = _make_agent()
         tc = SimpleNamespace(tool_name="bash", args_dict={"command":"ls -ltr"})
 
-        # First 3 calls go through (bash threshold is 4 for success)
-        for _ in range(4):
+        # Successful commands are never blocked by the circuit breaker
+        for _ in range(10):
             al._circuit_breaker_record(tc, "total 48\n-rw-r--r-- 1 user user 1234 auth.py")
 
-        # 5th call is blocked
-        assert al._circuit_breaker_check(tc) is not None
+        assert al._circuit_breaker_check(tc) is None
 
     def test_grep_same_pattern_loop(self):
         """Model greps for the same pattern 10 times."""

{drydock_cli-1.9.1 → drydock_cli-1.9.2}/tests/test_user_issues.py

@@ -62,8 +62,8 @@ class TestCondaEnv:
 # ============================================================================
 
 class TestCircuitBreakerEnforcement:
-    def test_circuit_breaker_blocks_not_just_warns(self):
-        """After threshold identical calls, the next must return an ERROR, not execute."""
+    def test_circuit_breaker_blocks_failed_commands(self):
+        """After 3 identical failed calls, the next must be blocked."""
         from drydock.core.agent_loop import AgentLoop
         from drydock.core.types import MessageList
 
@@ -71,16 +71,14 @@ class TestCircuitBreakerEnforcement:
         al.messages = MessageList()
         al._tool_call_history = {}
 
-        # Non-readonly bash: success threshold is 4
-        tc = SimpleNamespace(tool_name="bash", args_dict={"command": "ls -ltr"})
-        for _ in range(4):
-            al._circuit_breaker_record(tc, "file1.py")
+        tc = SimpleNamespace(tool_name="bash", args_dict={"command": "bad_cmd"})
+        for _ in range(3):
+            al._circuit_breaker_record(tc, "FAILED: command not found")
 
         result = al._circuit_breaker_check(tc)
-        assert result is not None, "Circuit breaker should block"
-        assert "CIRCUIT BREAKER" in result
-        # The blocked message should tell the model to STOP, not just warn
-        assert "STOP" in result or "Do NOT" in result or "MUST" in result
+        assert result is not None, "Circuit breaker should block failed commands after 3 repeats"
+        assert "failed" in result
+        assert "DIFFERENT" in result or "different" in result
 
     def test_circuit_breaker_resets_for_new_conversation(self):
         """Circuit breaker should reset between conversations, not cache forever."""
@@ -91,10 +89,9 @@ class TestCircuitBreakerEnforcement:
         al.messages = MessageList()
         al._tool_call_history = {}
 
-        # Non-readonly bash: success threshold is 4
-        tc = SimpleNamespace(tool_name="bash", args_dict={"command": "ls"})
-        for _ in range(4):
-            al._circuit_breaker_record(tc, "r1")
+        tc = SimpleNamespace(tool_name="bash", args_dict={"command": "bad_cmd"})
+        for _ in range(3):
+            al._circuit_breaker_record(tc, "FAILED: command not found")
         assert al._circuit_breaker_check(tc) is not None  # Blocked
 
         # Simulate new conversation — history should be clearable
@@ -121,8 +118,8 @@ class TestUnderstoodBug:
 # ============================================================================
 
 class TestCircuitBreakerSensitivity:
-    def test_circuit_breaker_should_have_decay(self):
-        """The circuit breaker should eventually allow re-running a command."""
+    def test_successful_commands_never_blocked(self):
+        """Successful commands are never blocked — only failed commands are."""
         from drydock.core.agent_loop import AgentLoop
         from drydock.core.types import MessageList
 
@@ -130,15 +127,24 @@ class TestCircuitBreakerSensitivity:
         al.messages = MessageList()
         al._tool_call_history = {}
 
-        # Non-readonly bash: success threshold is 4
         tc = SimpleNamespace(tool_name="bash", args_dict={"command": "git status"})
-        for _ in range(4):
+        for _ in range(10):
             al._circuit_breaker_record(tc, "clean")
-        assert al._circuit_breaker_check(tc) is not None  # Blocked
+        assert al._circuit_breaker_check(tc) is None  # Never blocked
 
-        # After clearing (simulating passage of time / new task), should work again
-        al._tool_call_history.clear()
-        assert al._circuit_breaker_check(tc) is None
+    def test_failed_commands_blocked_after_3(self):
+        """Failed commands are blocked after 3 repeats."""
+        from drydock.core.agent_loop import AgentLoop
+        from drydock.core.types import MessageList
+
+        al = object.__new__(AgentLoop)
+        al.messages = MessageList()
+        al._tool_call_history = {}
+
+        tc = SimpleNamespace(tool_name="bash", args_dict={"command": "git status"})
+        for _ in range(3):
+            al._circuit_breaker_record(tc, "FAILED: not a git repo")
+        assert al._circuit_breaker_check(tc) is not None  # Blocked
 
 
 # ============================================================================
@@ -201,8 +207,8 @@ class TestConsultantConfig:
 # ============================================================================
 
 class TestAutoConsult:
-    def test_circuit_breaker_suggests_consult(self):
-        """When circuit breaker fires, it should mention /consult or different approach."""
+    def test_circuit_breaker_suggests_different_approach(self):
+        """When circuit breaker fires on failed commands, it should suggest a different approach."""
         from drydock.core.agent_loop import AgentLoop
         from drydock.core.types import MessageList
 
@@ -210,14 +216,12 @@ class TestAutoConsult:
         al.messages = MessageList()
         al._tool_call_history = {}
 
-        # Non-readonly bash: success threshold is 4
-        tc = SimpleNamespace(tool_name="bash", args_dict={"command": "ls"})
-        for _ in range(4):
-            al._circuit_breaker_record(tc, "output")
+        tc = SimpleNamespace(tool_name="bash", args_dict={"command": "bad_cmd"})
+        for _ in range(3):
+            al._circuit_breaker_record(tc, "FAILED: command not found")
         result = al._circuit_breaker_check(tc)
-        assert result is not None, "Circuit breaker should have fired"
-        # Should suggest using /consult or mention consultant or different approach
-        assert "/consult" in result or "consultant" in result.lower() or "different" in result.lower()
+        assert result is not None, "Circuit breaker should have fired for failed command"
+        assert "different" in result.lower()
 
 
 # ============================================================================