drydock-cli 0.8.1__tar.gz → 0.9.0__tar.gz

{drydock_cli-0.8.1 → drydock_cli-0.9.0}/PKG-INFO

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

{drydock_cli-0.8.1 → drydock_cli-0.9.0}/drydock/core/agent_loop.py

@@ -599,15 +599,35 @@ class AgentLoop:
                         f"Consider stopping to verify your approach."
                     )
 
-                # Bash abuse detection: if model keeps using bash instead of
-                # search_replace/read_file, redirect it to the proper tools
-                if not has_made_edit and bash_count >= 10 and bash_count % 5 == 0:
-                    self._inject_system_note(
-                        f"STOP using bash. You have run {bash_count} bash commands without making an edit. "
-                        "Use search_replace to edit files, not bash. Use read_file to read files, not cat/head. "
-                        "Use grep (the tool) to search, not bash grep. "
-                        "Call search_replace NOW with your fix."
-                    )
+                # Bash abuse detection: model uses bash instead of proper tools
+                # This is the #1 cause of no-patch failures (88% of cases)
+                if not has_made_edit and bash_count >= 5:
+                    if bash_count == 5:
+                        self.messages.append(LLMMessage(
+                            role=Role.user,
+                            content=(
+                                "You have run 5 bash commands without making any edit. "
+                                "STOP using bash for reading/searching. Use the proper tools: "
+                                "read_file (not cat), grep (not bash grep), search_replace (not sed). "
+                                "Call search_replace NOW to fix the bug."
+                            )
+                        ))
+                    elif bash_count == 8:
+                        self.messages.append(LLMMessage(
+                            role=Role.user,
+                            content=(
+                                "WARNING: 8 bash commands, ZERO edits. You are wasting context. "
+                                "Bash does NOT fix bugs — search_replace does. "
+                                "Use search_replace on your NEXT response or the session ends."
+                            )
+                        ))
+                    elif bash_count >= 12:
+                        # Force stop — model is clearly stuck in bash loop
+                        yield AssistantEvent(
+                            content="\n\n[STOPPED: 12+ bash commands without any edit. Use search_replace.]\n",
+                            stopped_by_middleware=True,
+                        )
+                        return
 
                 # 3-Strike Rule: search_replace keeps failing
                 if search_replace_failures >= 3:

drydock_cli-0.9.0/drydock/core/hooks.py

@@ -0,0 +1,179 @@
+"""Hook system for DryDock lifecycle events.
+
+Hooks run shell scripts or Python callables at specific points
+in the agent's workflow. They are deterministic — they always run,
+unlike CLAUDE.md which is advisory.
+
+Hook events:
+- PreToolUse: Before any tool executes (can block with "deny")
+- PostToolUse: After a tool completes
+- SessionStart: When a new session begins
+- SessionEnd: When session ends
+- PreEdit: Before file write/edit (can block destructive patterns)
+- PostEdit: After file is written/edited
+
+Configure in ~/.drydock/hooks.json or .drydock/hooks.json:
+{
+  "hooks": [
+    {
+      "event": "PreToolUse",
+      "command": "python3 /path/to/guard.py",
+      "tools": ["bash", "write_file"]
+    }
+  ]
+}
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import subprocess
+from dataclasses import dataclass, field
+from enum import StrEnum, auto
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class HookEvent(StrEnum):
+    PRE_TOOL_USE = auto()
+    POST_TOOL_USE = auto()
+    SESSION_START = auto()
+    SESSION_END = auto()
+    PRE_EDIT = auto()
+    POST_EDIT = auto()
+
+
+class HookDecision(StrEnum):
+    ALLOW = auto()
+    DENY = auto()
+    ASK = auto()
+
+
+@dataclass
+class HookResult:
+    decision: HookDecision = HookDecision.ALLOW
+    message: str = ""
+
+
+@dataclass
+class HookConfig:
+    event: HookEvent
+    command: str
+    tools: list[str] = field(default_factory=list)  # Empty = all tools
+    timeout: int = 10
+
+
+class HookManager:
+    """Manages and executes lifecycle hooks."""
+
+    def __init__(self) -> None:
+        self._hooks: list[HookConfig] = []
+        self._loaded = False
+
+    def load_hooks(self, config_dir: Path | None = None) -> None:
+        """Load hooks from config files."""
+        if self._loaded:
+            return
+        self._loaded = True
+
+        search_paths = []
+        if config_dir:
+            search_paths.append(config_dir / "hooks.json")
+
+        # Check project and user dirs
+        project_hooks = Path.cwd() / ".drydock" / "hooks.json"
+        if project_hooks.exists():
+            search_paths.insert(0, project_hooks)
+
+        try:
+            from drydock.core.paths import VIBE_HOME
+            user_hooks = VIBE_HOME.path / "hooks.json"
+            if user_hooks.exists():
+                search_paths.append(user_hooks)
+        except Exception:
+            pass
+
+        for path in search_paths:
+            try:
+                if path.exists():
+                    data = json.loads(path.read_text())
+                    for h in data.get("hooks", []):
+                        self._hooks.append(HookConfig(
+                            event=HookEvent(h["event"].lower().replace("-", "_")),
+                            command=h["command"],
+                            tools=h.get("tools", []),
+                            timeout=h.get("timeout", 10),
+                        ))
+                    logger.info("Loaded %d hooks from %s", len(data.get("hooks", [])), path)
+            except Exception as e:
+                logger.warning("Failed to load hooks from %s: %s", path, e)
+
+    def get_hooks(self, event: HookEvent, tool_name: str = "") -> list[HookConfig]:
+        """Get hooks matching an event and optional tool name."""
+        return [
+            h for h in self._hooks
+            if h.event == event
+            and (not h.tools or tool_name in h.tools)
+        ]
+
+    async def run_hooks(
+        self, event: HookEvent, tool_name: str = "", context: dict[str, Any] | None = None
+    ) -> HookResult:
+        """Execute all hooks for an event. Returns the most restrictive result."""
+        hooks = self.get_hooks(event, tool_name)
+        if not hooks:
+            return HookResult()
+
+        most_restrictive = HookResult()
+
+        for hook in hooks:
+            try:
+                result = await self._execute_hook(hook, context or {})
+                if result.decision == HookDecision.DENY:
+                    return result  # Deny immediately
+                if result.decision == HookDecision.ASK and most_restrictive.decision == HookDecision.ALLOW:
+                    most_restrictive = result
+            except Exception as e:
+                logger.warning("Hook %s failed: %s", hook.command, e)
+
+        return most_restrictive
+
+    async def _execute_hook(self, hook: HookConfig, context: dict[str, Any]) -> HookResult:
+        """Execute a single hook command."""
+        import asyncio
+
+        env = {
+            **__import__("os").environ,
+            "DRYDOCK_HOOK_EVENT": hook.event.value,
+            "DRYDOCK_HOOK_CONTEXT": json.dumps(context, default=str),
+        }
+
+        try:
+            proc = await asyncio.create_subprocess_shell(
+                hook.command,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                env=env,
+            )
+            stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=hook.timeout)
+
+            output = stdout.decode("utf-8", errors="replace").strip()
+
+            # Parse output for decision
+            if "DENY" in output.upper():
+                return HookResult(decision=HookDecision.DENY, message=output)
+            if "ASK" in output.upper():
+                return HookResult(decision=HookDecision.ASK, message=output)
+
+            return HookResult(decision=HookDecision.ALLOW, message=output)
+
+        except asyncio.TimeoutError:
+            logger.warning("Hook timed out: %s", hook.command)
+            return HookResult()
+
+
+# Global hook manager instance
+hook_manager = HookManager()

{drydock_cli-0.8.1 → drydock_cli-0.9.0}/drydock/core/prompts/cli.md

@@ -161,6 +161,13 @@ Bug Fixing in Open-Source Repos
 
 NEVER edit test files. The bug is in the library source code, not the tests.
 
+CRITICAL — Tool Usage:
+- To EDIT files: use search_replace. NEVER use bash with sed/awk/echo to edit files.
+- To READ files: use read_file. NEVER use bash with cat/head/tail.
+- To SEARCH code: use grep. NEVER use bash with grep/find/rg.
+- bash is ONLY for: running tests, checking git status, installing packages, running scripts.
+- If you have not called search_replace, you have not fixed anything. Bash commands do not fix bugs.
+
 Context Budget:
 Your context window is your most important resource. Every grep result and file read consumes it.
 Performance degrades as context fills. Budget your investigation:

drydock_cli-0.9.0/drydock/core/tools/builtins/glob_tool.py

@@ -0,0 +1,94 @@
+"""Glob tool — fast file pattern matching.
+
+Matches files by glob pattern (e.g., "**/*.py", "src/**/*.ts").
+Returns sorted file paths. Read-only, always auto-approved.
+"""
+
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator
+from pathlib import Path
+from typing import TYPE_CHECKING, ClassVar, final
+
+from pydantic import BaseModel, Field
+
+from drydock.core.tools.base import (
+    BaseTool, BaseToolConfig, BaseToolState, InvokeContext, ToolError, ToolPermission,
+)
+from drydock.core.tools.ui import ToolCallDisplay, ToolResultDisplay, ToolUIData
+from drydock.core.types import ToolStreamEvent
+
+if TYPE_CHECKING:
+    from drydock.core.types import ToolResultEvent
+
+
+class GlobArgs(BaseModel):
+    pattern: str = Field(description="Glob pattern (e.g., '**/*.py', 'src/**/*.ts')")
+    path: str = Field(default=".", description="Directory to search in")
+
+
+class GlobResult(BaseModel):
+    files: list[str]
+    count: int
+    truncated: bool = False
+
+
+class GlobConfig(BaseToolConfig):
+    permission: ToolPermission = ToolPermission.ALWAYS
+    max_results: int = 200
+
+
+class Glob(
+    BaseTool[GlobArgs, GlobResult, GlobConfig, BaseToolState],
+    ToolUIData[GlobArgs, GlobResult],
+):
+    description: ClassVar[str] = (
+        "Find files matching a glob pattern. Fast file discovery."
+    )
+
+    @classmethod
+    def format_call_display(cls, args: GlobArgs) -> ToolCallDisplay:
+        return ToolCallDisplay(summary=f"glob: {args.pattern}")
+
+    @classmethod
+    def get_result_display(cls, event: ToolResultEvent) -> ToolResultDisplay:
+        if isinstance(event.result, GlobResult):
+            return ToolResultDisplay(
+                success=True, message=f"Found {event.result.count} files"
+            )
+        return ToolResultDisplay(success=True, message="Glob complete")
+
+    @classmethod
+    def get_status_text(cls) -> str:
+        return "Searching files"
+
+    def resolve_permission(self, args: GlobArgs) -> ToolPermission | None:
+        return ToolPermission.ALWAYS
+
+    @final
+    async def run(
+        self, args: GlobArgs, ctx: InvokeContext | None = None
+    ) -> AsyncGenerator[ToolStreamEvent | GlobResult, None]:
+        search_dir = Path(args.path).expanduser()
+        if not search_dir.is_absolute():
+            search_dir = Path.cwd() / search_dir
+
+        if not search_dir.is_dir():
+            raise ToolError(f"Directory not found: {search_dir}")
+
+        try:
+            matches = sorted(
+                str(p.relative_to(search_dir))
+                for p in search_dir.glob(args.pattern)
+                if p.is_file()
+                and "__pycache__" not in str(p)
+                and ".git/" not in str(p)
+                and "node_modules/" not in str(p)
+            )
+        except Exception as e:
+            raise ToolError(f"Glob error: {e}") from e
+
+        truncated = len(matches) > self.config.max_results
+        files = matches[:self.config.max_results]
+
+        yield GlobResult(files=files, count=len(matches), truncated=truncated)

drydock_cli-0.9.0/drydock/core/tools/builtins/notebook_edit.py

@@ -0,0 +1,96 @@
+"""NotebookEdit tool — edit Jupyter notebook cells.
+
+Supports editing code and markdown cells in .ipynb files.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import AsyncGenerator
+from pathlib import Path
+from typing import ClassVar, final
+
+from pydantic import BaseModel, Field
+
+from drydock.core.tools.base import (
+    BaseTool, BaseToolConfig, BaseToolState, InvokeContext, ToolError, ToolPermission,
+)
+from drydock.core.tools.ui import ToolCallDisplay, ToolResultDisplay, ToolUIData
+from drydock.core.types import ToolStreamEvent, ToolResultEvent
+
+
+class NotebookEditArgs(BaseModel):
+    path: str = Field(description="Path to the .ipynb file")
+    cell_index: int = Field(description="Cell index to edit (0-based)")
+    new_source: str = Field(description="New source content for the cell")
+    cell_type: str = Field(default="code", description="Cell type: 'code' or 'markdown'")
+
+
+class NotebookEditResult(BaseModel):
+    path: str
+    cell_index: int
+    cell_type: str
+    total_cells: int
+
+
+class NotebookEdit(
+    BaseTool[NotebookEditArgs, NotebookEditResult, BaseToolConfig, BaseToolState],
+    ToolUIData[NotebookEditArgs, NotebookEditResult],
+):
+    description: ClassVar[str] = "Edit a cell in a Jupyter notebook (.ipynb file)."
+
+    @classmethod
+    def format_call_display(cls, args: NotebookEditArgs) -> ToolCallDisplay:
+        return ToolCallDisplay(summary=f"notebook_edit: cell {args.cell_index} in {args.path}")
+
+    @classmethod
+    def get_result_display(cls, event: ToolResultEvent) -> ToolResultDisplay:
+        if isinstance(event.result, NotebookEditResult):
+            return ToolResultDisplay(success=True, message=f"Edited cell {event.result.cell_index}")
+        return ToolResultDisplay(success=True, message="Notebook edited")
+
+    @classmethod
+    def get_status_text(cls) -> str:
+        return "Editing notebook"
+
+    @final
+    async def run(
+        self, args: NotebookEditArgs, ctx: InvokeContext | None = None
+    ) -> AsyncGenerator[ToolStreamEvent | NotebookEditResult, None]:
+        file_path = Path(args.path).expanduser()
+        if not file_path.is_absolute():
+            file_path = Path.cwd() / file_path
+
+        if not file_path.exists():
+            raise ToolError(f"Notebook not found: {file_path}")
+
+        if not str(file_path).endswith(".ipynb"):
+            raise ToolError("File must be a .ipynb notebook")
+
+        try:
+            with open(file_path, encoding="utf-8") as f:
+                notebook = json.load(f)
+        except (json.JSONDecodeError, OSError) as e:
+            raise ToolError(f"Cannot read notebook: {e}") from e
+
+        cells = notebook.get("cells", [])
+        if args.cell_index < 0 or args.cell_index >= len(cells):
+            raise ToolError(f"Cell index {args.cell_index} out of range (0-{len(cells)-1})")
+
+        # Update the cell
+        cell = cells[args.cell_index]
+        cell["source"] = args.new_source.split("\n")
+        cell["cell_type"] = args.cell_type
+
+        try:
+            with open(file_path, "w", encoding="utf-8") as f:
+                json.dump(notebook, f, indent=1, ensure_ascii=False)
+        except OSError as e:
+            raise ToolError(f"Cannot write notebook: {e}") from e
+
+        yield NotebookEditResult(
+            path=str(file_path),
+            cell_index=args.cell_index,
+            cell_type=args.cell_type,
+            total_cells=len(cells),
+        )

drydock_cli-0.9.0/drydock/core/tools/builtins/prompts/glob.md

@@ -0,0 +1,9 @@
+Find files matching a glob pattern. Returns sorted file paths.
+
+Examples:
+- `glob(pattern="**/*.py")` — all Python files
+- `glob(pattern="src/**/*.ts", path=".")` — TypeScript files under src/
+- `glob(pattern="*.md")` — markdown files in current directory
+- `glob(pattern="**/test_*.py")` — all test files
+
+Use this instead of `bash find` for file discovery.

drydock_cli-0.9.0/drydock/core/tools/builtins/prompts/notebook_edit.md

@@ -0,0 +1,7 @@
+Edit a cell in a Jupyter notebook (.ipynb file).
+
+Arguments:
+- path: Path to the .ipynb file
+- cell_index: Cell index to edit (0-based)
+- new_source: New source content for the cell
+- cell_type: "code" or "markdown" (default: "code")

{drydock_cli-0.8.1 → drydock_cli-0.9.0}/drydock/core/tools/builtins/prompts/swe_bench.md

@@ -29,3 +29,10 @@ COMMON PATTERNS:
 - Missing import: grep for where the symbol is defined, add the import
 - Off-by-one: check loop bounds and slice indices
 - Unhashable type: wrap mutable container in tuple() before hashing
+
+AFTER YOUR FIRST EDIT:
+After making your first edit, ALWAYS check:
+1. grep for other files that import/use the function you changed
+2. If you edited a base class, check if subclasses override the method
+3. If you edited a config/settings file, check if there's a related migration
+4. If you edited a backend, check if other backends need the same fix

drydock_cli-0.9.0/drydock/core/tools/builtins/prompts/task_manager.md

@@ -0,0 +1,8 @@
+Track work items during a session.
+
+Tools:
+- `task_create(title, description)` — Create a new task
+- `task_list()` — List all tasks and their status
+- `task_update(task_id, status, notes)` — Update status: pending, in_progress, completed, blocked
+
+Use these to break complex work into trackable steps.

drydock_cli-0.9.0/drydock/core/tools/builtins/task_manager.py

@@ -0,0 +1,169 @@
+"""Task lifecycle tools — create, get, list, update tasks.
+
+Provides interactive task management for tracking work items
+during a session, similar to Claude Code's TaskCreate/Get/List/Update.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import AsyncGenerator
+from pathlib import Path
+from typing import ClassVar, final
+from uuid import uuid4
+
+from pydantic import BaseModel, Field
+
+from drydock.core.tools.base import (
+    BaseTool, BaseToolConfig, BaseToolState, InvokeContext, ToolError, ToolPermission,
+)
+from drydock.core.tools.ui import ToolCallDisplay, ToolResultDisplay, ToolUIData
+from drydock.core.types import ToolStreamEvent, ToolResultEvent
+
+# In-memory task store (per session)
+_TASKS: dict[str, dict] = {}
+_TASK_COUNTER = 0
+
+
+class TaskCreateArgs(BaseModel):
+    title: str = Field(description="Brief title for the task")
+    description: str = Field(default="", description="Detailed description")
+
+
+class TaskCreateResult(BaseModel):
+    task_id: str
+    title: str
+    status: str = "pending"
+
+
+class TaskCreate(
+    BaseTool[TaskCreateArgs, TaskCreateResult, BaseToolConfig, BaseToolState],
+    ToolUIData[TaskCreateArgs, TaskCreateResult],
+):
+    description: ClassVar[str] = "Create a new task to track work."
+
+    @classmethod
+    def format_call_display(cls, args: TaskCreateArgs) -> ToolCallDisplay:
+        return ToolCallDisplay(summary=f"task_create: {args.title[:50]}")
+
+    @classmethod
+    def get_result_display(cls, event: ToolResultEvent) -> ToolResultDisplay:
+        if isinstance(event.result, TaskCreateResult):
+            return ToolResultDisplay(success=True, message=f"Created task #{event.result.task_id}")
+        return ToolResultDisplay(success=True, message="Task created")
+
+    @classmethod
+    def get_status_text(cls) -> str:
+        return "Creating task"
+
+    def resolve_permission(self, args: TaskCreateArgs) -> ToolPermission | None:
+        return ToolPermission.ALWAYS
+
+    @final
+    async def run(
+        self, args: TaskCreateArgs, ctx: InvokeContext | None = None
+    ) -> AsyncGenerator[ToolStreamEvent | TaskCreateResult, None]:
+        global _TASK_COUNTER
+        _TASK_COUNTER += 1
+        task_id = str(_TASK_COUNTER)
+
+        _TASKS[task_id] = {
+            "id": task_id,
+            "title": args.title,
+            "description": args.description,
+            "status": "pending",
+        }
+
+        yield TaskCreateResult(task_id=task_id, title=args.title)
+
+
+class TaskListArgs(BaseModel):
+    pass
+
+
+class TaskListResult(BaseModel):
+    tasks: list[dict]
+    count: int
+
+
+class TaskList(
+    BaseTool[TaskListArgs, TaskListResult, BaseToolConfig, BaseToolState],
+    ToolUIData[TaskListArgs, TaskListResult],
+):
+    description: ClassVar[str] = "List all tasks and their status."
+
+    @classmethod
+    def format_call_display(cls, args: TaskListArgs) -> ToolCallDisplay:
+        return ToolCallDisplay(summary="task_list")
+
+    @classmethod
+    def get_result_display(cls, event: ToolResultEvent) -> ToolResultDisplay:
+        if isinstance(event.result, TaskListResult):
+            return ToolResultDisplay(success=True, message=f"{event.result.count} tasks")
+        return ToolResultDisplay(success=True, message="Tasks listed")
+
+    @classmethod
+    def get_status_text(cls) -> str:
+        return "Listing tasks"
+
+    def resolve_permission(self, args: TaskListArgs) -> ToolPermission | None:
+        return ToolPermission.ALWAYS
+
+    @final
+    async def run(
+        self, args: TaskListArgs, ctx: InvokeContext | None = None
+    ) -> AsyncGenerator[ToolStreamEvent | TaskListResult, None]:
+        tasks = list(_TASKS.values())
+        yield TaskListResult(tasks=tasks, count=len(tasks))
+
+
+class TaskUpdateArgs(BaseModel):
+    task_id: str = Field(description="Task ID to update")
+    status: str = Field(description="New status: pending, in_progress, completed, blocked")
+    notes: str = Field(default="", description="Optional notes")
+
+
+class TaskUpdateResult(BaseModel):
+    task_id: str
+    status: str
+    title: str
+
+
+class TaskUpdate(
+    BaseTool[TaskUpdateArgs, TaskUpdateResult, BaseToolConfig, BaseToolState],
+    ToolUIData[TaskUpdateArgs, TaskUpdateResult],
+):
+    description: ClassVar[str] = "Update a task's status."
+
+    @classmethod
+    def format_call_display(cls, args: TaskUpdateArgs) -> ToolCallDisplay:
+        return ToolCallDisplay(summary=f"task_update: #{args.task_id} → {args.status}")
+
+    @classmethod
+    def get_result_display(cls, event: ToolResultEvent) -> ToolResultDisplay:
+        if isinstance(event.result, TaskUpdateResult):
+            return ToolResultDisplay(success=True, message=f"#{event.result.task_id} → {event.result.status}")
+        return ToolResultDisplay(success=True, message="Task updated")
+
+    @classmethod
+    def get_status_text(cls) -> str:
+        return "Updating task"
+
+    def resolve_permission(self, args: TaskUpdateArgs) -> ToolPermission | None:
+        return ToolPermission.ALWAYS
+
+    @final
+    async def run(
+        self, args: TaskUpdateArgs, ctx: InvokeContext | None = None
+    ) -> AsyncGenerator[ToolStreamEvent | TaskUpdateResult, None]:
+        if args.task_id not in _TASKS:
+            raise ToolError(f"Task #{args.task_id} not found")
+
+        task = _TASKS[args.task_id]
+        task["status"] = args.status
+        if args.notes:
+            task["notes"] = args.notes
+
+        yield TaskUpdateResult(
+            task_id=args.task_id, status=args.status, title=task["title"]
+        )