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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 0.8.2
+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.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.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.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"]
+        )

drydock_cli-0.9.0/drydock/skills/batch/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: batch
+description: Apply the same change across many files. Generates a plan, then processes each file.
+user-invocable: true
+allowed-tools:
+  - bash
+  - grep
+  - read_file
+  - search_replace
+  - write_file
+  - task_create
+  - task_update
+---
+
+# Batch Changes
+
+Apply the same change pattern across multiple files.
+
+## Workflow
+
+1. **Identify scope**: Use `grep` or `glob` to find all files that need the change
+2. **Create plan**: List each file and the specific change needed
+3. **Track with tasks**: Create a task for each file change
+4. **Execute**: Process each file one at a time
+5. **Verify**: Read back each changed file to confirm
+
+## Rules
+
+- Process ONE file at a time — do not batch edits
+- Create a task_create for each file before editing
+- Mark task_update as completed after each file
+- If a file edit fails, skip it and note the failure
+- After all files, report: X/Y files changed successfully
+
+## Example
+
+User: "Add type hints to all function parameters in src/"
+
+1. `grep -r "def " src/ --include="*.py"` → find all functions
+2. For each file with untyped params:
+   - `task_create`: "Add type hints to src/utils.py"
+   - `read_file` the function
+   - `search_replace` to add types
+   - `task_update`: completed
+3. Summary: "Added type hints to 12/15 files (3 skipped: complex generics)"

drydock_cli-0.9.0/drydock/skills/simplify/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: simplify
+description: Review changed code for reuse, quality, and efficiency. Fix issues found.
+user-invocable: true
+allowed-tools:
+  - bash
+  - grep
+  - read_file
+  - search_replace
+---
+
+# Simplify
+
+Review recent changes for code quality and fix issues.
+
+## Three-Pass Review
+
+### Pass 1: Duplication
+- Check if any new code duplicates existing patterns
+- Look for copy-pasted blocks that should be a shared function
+- Search for similar patterns: `grep -r "pattern" --include="*.py"`
+
+### Pass 2: Complexity
+- Functions over 30 lines → should they be split?
+- Nesting deeper than 3 levels → use early returns
+- Long parameter lists → use a config object or dataclass
+
+### Pass 3: Correctness
+- Missing error handling on I/O operations
+- Unclosed resources (files, connections)
+- Missing null/empty checks on external input
+- Type mismatches
+
+## Rules
+
+- Fix mechanical issues immediately (duplication, style)
+- Ask about judgment calls (architecture, naming)
+- Keep changes minimal — don't refactor beyond what's needed
+- Run `git diff` first to see what changed

{drydock_cli-0.8.2 → drydock_cli-0.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "0.8.2"
+version = "0.9.0"
 description = "Drydock — nautical CLI coding agent"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -81,6 +81,8 @@ include = ["drydock/"]
 "drydock/skills/investigate" = "drydock/skills/investigate"
 "drydock/skills/review" = "drydock/skills/review"
 "drydock/skills/ship" = "drydock/skills/ship"
+"drydock/skills/batch" = "drydock/skills/batch"
+"drydock/skills/simplify" = "drydock/skills/simplify"
 
 
 [project.scripts]