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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 0.8.2
+Version: 1.0.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.2 → drydock_cli-1.0.0}/drydock/core/agents/models.py

@@ -53,11 +53,22 @@ class AgentProfile:
     safety: AgentSafety
     agent_type: AgentType = AgentType.AGENT
     overrides: dict[str, Any] = field(default_factory=dict)
+    # New fields for feature parity with Claude Code
+    model: str = ""  # Per-subagent model selection (e.g., "gemini-2.5-pro")
+    max_turns: int | None = None  # Per-subagent turn limit
+    background: bool = False  # Run in background (non-blocking)
+    isolation: str = ""  # "worktree" for git worktree isolation
+    initial_prompt: str = ""  # Auto-run this prompt on start
+    allowed_tools: list[str] = field(default_factory=list)  # Restrict tools
+    hooks: list[str] = field(default_factory=list)  # Hook configs
 
     def apply_to_config(self, base: VibeConfig) -> VibeConfig:
         from drydock.core.config import VibeConfig as VC
 
         merged = _deep_merge(base.model_dump(), self.overrides)
+        # Apply per-subagent model if set
+        if self.model:
+            merged["active_model"] = self.model
         return VC.model_validate(merged)
 
     @classmethod
@@ -70,9 +81,45 @@ class AgentProfile:
             description=data.pop("description", ""),
             safety=AgentSafety(data.pop("safety", AgentSafety.NEUTRAL)),
             agent_type=AgentType(data.pop("agent_type", AgentType.AGENT)),
+            model=data.pop("model", ""),
+            max_turns=data.pop("max_turns", None),
+            background=data.pop("background", False),
+            isolation=data.pop("isolation", ""),
+            initial_prompt=data.pop("initial_prompt", ""),
+            allowed_tools=data.pop("allowed_tools", []),
+            hooks=data.pop("hooks", []),
             overrides=data,
         )
 
+    @classmethod
+    def from_markdown(cls, path: Path) -> AgentProfile:
+        """Load agent profile from Markdown with YAML frontmatter."""
+        import yaml
+        content = path.read_text(encoding="utf-8")
+        if not content.startswith("---"):
+            raise ValueError(f"No YAML frontmatter in {path}")
+        parts = content.split("---", 2)
+        if len(parts) < 3:
+            raise ValueError(f"Invalid frontmatter in {path}")
+        meta = yaml.safe_load(parts[1]) or {}
+        body = parts[2].strip()
+
+        return cls(
+            name=meta.get("name", path.stem),
+            display_name=meta.get("display_name", meta.get("name", path.stem)),
+            description=meta.get("description", body[:200]),
+            safety=AgentSafety(meta.get("safety", AgentSafety.NEUTRAL)),
+            agent_type=AgentType(meta.get("agent_type", AgentType.SUBAGENT)),
+            model=meta.get("model", ""),
+            max_turns=meta.get("max_turns"),
+            background=meta.get("background", False),
+            isolation=meta.get("isolation", ""),
+            initial_prompt=meta.get("initial_prompt", ""),
+            allowed_tools=meta.get("allowed_tools") or meta.get("allowed-tools") or [],
+            hooks=meta.get("hooks", []),
+            overrides=meta.get("overrides", {}),
+        )
+
 
 CHAT_AGENT_TOOLS = ["grep", "read_file", "ask_user_question", "task"]
 DIAGNOSTIC_AGENT_TOOLS = ["grep", "read_file", "bash"]

drydock_cli-1.0.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.2 → drydock_cli-1.0.0}/drydock/core/skills/models.py

@@ -44,6 +44,24 @@ class SkillMetadata(BaseModel):
         validation_alias="user-invocable",
         description="Controls whether the skill appears in the slash command menu.",
     )
+    # New fields for Claude Code parity
+    context: str = Field(
+        default="",
+        description="'fork' to run in a subagent with its own context window.",
+    )
+    agent: str = Field(
+        default="",
+        description="Subagent type to use when context is 'fork' (e.g., 'explore').",
+    )
+    model: str = Field(
+        default="",
+        description="Model to use for this skill (overrides active_model).",
+    )
+    disable_model_invocation: bool = Field(
+        default=False,
+        validation_alias="disable-model-invocation",
+        description="If true, only users can invoke this skill (not the model).",
+    )
 
     @field_validator("allowed_tools", mode="before")
     @classmethod

drydock_cli-1.0.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-1.0.0/drydock/core/tools/builtins/invoke_skill.py

@@ -0,0 +1,100 @@
+"""Invoke Skill tool — lets the model call skills programmatically.
+
+The model can invoke any registered skill by name, equivalent to
+the user typing /skill-name in the chat.
+"""
+
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator
+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 InvokeSkillArgs(BaseModel):
+    skill_name: str = Field(description="Name of the skill to invoke (e.g., 'investigate', 'review')")
+    arguments: str = Field(default="", description="Arguments to pass to the skill")
+
+
+class InvokeSkillResult(BaseModel):
+    skill_name: str
+    content: str
+    loaded: bool
+
+
+class InvokeSkill(
+    BaseTool[InvokeSkillArgs, InvokeSkillResult, BaseToolConfig, BaseToolState],
+    ToolUIData[InvokeSkillArgs, InvokeSkillResult],
+):
+    description: ClassVar[str] = (
+        "Invoke a skill by name. Use this to activate specialized workflows "
+        "like /investigate, /review, /ship, /batch, etc."
+    )
+
+    @classmethod
+    def format_call_display(cls, args: InvokeSkillArgs) -> ToolCallDisplay:
+        return ToolCallDisplay(summary=f"skill: /{args.skill_name}")
+
+    @classmethod
+    def get_result_display(cls, event: ToolResultEvent) -> ToolResultDisplay:
+        if isinstance(event.result, InvokeSkillResult):
+            return ToolResultDisplay(success=event.result.loaded, message=f"/{event.result.skill_name}")
+        return ToolResultDisplay(success=True, message="Skill invoked")
+
+    @classmethod
+    def get_status_text(cls) -> str:
+        return "Loading skill"
+
+    def resolve_permission(self, args: InvokeSkillArgs) -> ToolPermission | None:
+        return ToolPermission.ALWAYS
+
+    @final
+    async def run(
+        self, args: InvokeSkillArgs, ctx: InvokeContext | None = None
+    ) -> AsyncGenerator[ToolStreamEvent | InvokeSkillResult, None]:
+        if not ctx or not ctx.agent_manager:
+            raise ToolError("No agent manager available")
+
+        # Find the skill
+        try:
+            from drydock.core.skills.manager import SkillManager
+            config = ctx.agent_manager.config
+            manager = SkillManager(lambda: config)
+            skills = manager.available_skills
+
+            if args.skill_name not in skills:
+                available = ", ".join(sorted(skills.keys()))
+                raise ToolError(
+                    f"Skill '{args.skill_name}' not found. "
+                    f"Available: {available}"
+                )
+
+            skill_info = skills[args.skill_name]
+            content = skill_info.skill_path.read_text(encoding="utf-8") if skill_info.skill_path else ""
+
+            # Strip frontmatter
+            if content.startswith("---"):
+                parts = content.split("---", 2)
+                content = parts[2].strip() if len(parts) >= 3 else content
+
+            # Prepend arguments if provided
+            if args.arguments:
+                content = f"{args.arguments}\n\n{content}"
+
+            yield InvokeSkillResult(
+                skill_name=args.skill_name,
+                content=content,
+                loaded=True,
+            )
+
+        except ToolError:
+            raise
+        except Exception as e:
+            raise ToolError(f"Failed to load skill: {e}") from e

drydock_cli-1.0.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-1.0.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-1.0.0/drydock/core/tools/builtins/prompts/invoke_skill.md

@@ -0,0 +1,9 @@
+Invoke a skill by name to activate specialized workflows.
+
+Examples:
+- `invoke_skill(skill_name="investigate", arguments="Fix the login timeout bug")`
+- `invoke_skill(skill_name="review")` — run a code review
+- `invoke_skill(skill_name="ship")` — run the shipping pipeline
+- `invoke_skill(skill_name="batch", arguments="Add type hints to all files in src/")`
+
+Available skills depend on what's installed. Use this to activate domain-specific workflows.

drydock_cli-1.0.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-1.0.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-1.0.0/drydock/core/tools/builtins/prompts/worktree.md

@@ -0,0 +1,7 @@
+Git worktree tools for parallel work in isolated copies.
+
+- `enter_worktree(branch="feature-x")` — Create isolated worktree and switch to it
+- `exit_worktree(cleanup=true)` — Return to main directory, optionally remove worktree
+
+Use worktrees when you need to make changes without affecting the main branch,
+or to work on multiple things in parallel.