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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 0.9.0
+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.9.0 → 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-0.9.0 → 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/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/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/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.

drydock_cli-1.0.0/drydock/core/tools/builtins/worktree.py

@@ -0,0 +1,166 @@
+"""Worktree tools — git worktree isolation for parallel work.
+
+EnterWorktree creates an isolated copy of the repo.
+ExitWorktree returns to the main working directory.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import shutil
+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 EnterWorktreeArgs(BaseModel):
+    branch: str = Field(default="", description="Branch name for the worktree (auto-generated if empty)")
+
+
+class EnterWorktreeResult(BaseModel):
+    worktree_path: str
+    branch: str
+    original_dir: str
+
+
+class EnterWorktree(
+    BaseTool[EnterWorktreeArgs, EnterWorktreeResult, BaseToolConfig, BaseToolState],
+    ToolUIData[EnterWorktreeArgs, EnterWorktreeResult],
+):
+    description: ClassVar[str] = "Create an isolated git worktree for parallel work."
+
+    @classmethod
+    def format_call_display(cls, args: EnterWorktreeArgs) -> ToolCallDisplay:
+        return ToolCallDisplay(summary=f"enter_worktree: {args.branch or 'auto'}")
+
+    @classmethod
+    def get_result_display(cls, event: ToolResultEvent) -> ToolResultDisplay:
+        if isinstance(event.result, EnterWorktreeResult):
+            return ToolResultDisplay(success=True, message=f"Worktree: {event.result.branch}")
+        return ToolResultDisplay(success=True, message="Worktree created")
+
+    @classmethod
+    def get_status_text(cls) -> str:
+        return "Creating worktree"
+
+    @final
+    async def run(
+        self, args: EnterWorktreeArgs, ctx: InvokeContext | None = None
+    ) -> AsyncGenerator[ToolStreamEvent | EnterWorktreeResult, None]:
+        cwd = Path.cwd()
+
+        # Check we're in a git repo
+        proc = await asyncio.create_subprocess_exec(
+            "git", "rev-parse", "--git-dir",
+            stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, _ = await proc.communicate()
+        if proc.returncode != 0:
+            raise ToolError("Not in a git repository")
+
+        branch = args.branch or f"drydock-worktree-{os.getpid()}"
+        worktree_path = cwd.parent / f".drydock-worktree-{branch}"
+
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                "git", "worktree", "add", "-b", branch, str(worktree_path),
+                stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE,
+            )
+            _, stderr = await proc.communicate()
+            if proc.returncode != 0:
+                # Try without -b (branch might exist)
+                proc = await asyncio.create_subprocess_exec(
+                    "git", "worktree", "add", str(worktree_path), branch,
+                    stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE,
+                )
+                _, stderr = await proc.communicate()
+                if proc.returncode != 0:
+                    raise ToolError(f"Failed to create worktree: {stderr.decode()}")
+
+            os.chdir(worktree_path)
+
+            yield EnterWorktreeResult(
+                worktree_path=str(worktree_path),
+                branch=branch,
+                original_dir=str(cwd),
+            )
+        except ToolError:
+            raise
+        except Exception as e:
+            raise ToolError(f"Worktree error: {e}") from e
+
+
+class ExitWorktreeArgs(BaseModel):
+    cleanup: bool = Field(default=False, description="Remove the worktree after exiting")
+
+
+class ExitWorktreeResult(BaseModel):
+    returned_to: str
+    cleaned_up: bool
+
+
+class ExitWorktree(
+    BaseTool[ExitWorktreeArgs, ExitWorktreeResult, BaseToolConfig, BaseToolState],
+    ToolUIData[ExitWorktreeArgs, ExitWorktreeResult],
+):
+    description: ClassVar[str] = "Exit the current git worktree and return to main directory."
+
+    @classmethod
+    def format_call_display(cls, args: ExitWorktreeArgs) -> ToolCallDisplay:
+        return ToolCallDisplay(summary="exit_worktree")
+
+    @classmethod
+    def get_result_display(cls, event: ToolResultEvent) -> ToolResultDisplay:
+        return ToolResultDisplay(success=True, message="Returned to main")
+
+    @classmethod
+    def get_status_text(cls) -> str:
+        return "Exiting worktree"
+
+    @final
+    async def run(
+        self, args: ExitWorktreeArgs, ctx: InvokeContext | None = None
+    ) -> AsyncGenerator[ToolStreamEvent | ExitWorktreeResult, None]:
+        cwd = Path.cwd()
+
+        # Find the main worktree
+        proc = await asyncio.create_subprocess_exec(
+            "git", "worktree", "list", "--porcelain",
+            stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, _ = await proc.communicate()
+
+        # First worktree in the list is the main one
+        main_dir = ""
+        for line in stdout.decode().split("\n"):
+            if line.startswith("worktree "):
+                main_dir = line.split(" ", 1)[1].strip()
+                break
+
+        if not main_dir or not Path(main_dir).is_dir():
+            raise ToolError("Cannot find main worktree directory")
+
+        os.chdir(main_dir)
+
+        cleaned = False
+        if args.cleanup and str(cwd) != main_dir:
+            try:
+                proc = await asyncio.create_subprocess_exec(
+                    "git", "worktree", "remove", "--force", str(cwd),
+                    stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE,
+                )
+                await proc.communicate()
+                cleaned = proc.returncode == 0
+            except Exception:
+                pass
+
+        yield ExitWorktreeResult(returned_to=main_dir, cleaned_up=cleaned)

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

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