drydock-cli 2.3.0__tar.gz → 2.3.2__tar.gz

{drydock_cli-2.3.0 → drydock_cli-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.3.0
+Version: 2.3.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-2.3.0 → drydock_cli-2.3.2}/drydock/core/skills/models.py

@@ -88,6 +88,9 @@ class SkillInfo(BaseModel):
     metadata: dict[str, str] = Field(default_factory=dict)
     allowed_tools: list[str] = Field(default_factory=list)
     user_invocable: bool = True
+    context: str = ""  # 'fork' to run in subagent
+    agent: str = ""  # subagent type when context='fork'
+    model: str = ""  # model override
     skill_path: Path
 
     model_config = {"arbitrary_types_allowed": True}
@@ -106,5 +109,8 @@ class SkillInfo(BaseModel):
             metadata=meta.metadata,
             allowed_tools=meta.allowed_tools,
             user_invocable=meta.user_invocable,
+            context=meta.context,
+            agent=meta.agent,
+            model=meta.model,
             skill_path=skill_path.resolve(),
         )

drydock_cli-2.3.2/drydock/core/tools/builtins/invoke_skill.py

@@ -0,0 +1,204 @@
+"""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.
+
+Supports:
+- $ARGUMENTS, $0, $1 positional substitution in skill content
+- !`command` shell preprocessing (runs at load time, output replaces command)
+- context: fork for subagent execution
+"""
+
+from __future__ import annotations
+
+import re
+import subprocess
+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
+
+
+def _substitute_arguments(content: str, arguments: str, skill_dir: str = "") -> str:
+    """Replace $ARGUMENTS, $0, $1, ${SKILL_DIR} in skill content."""
+    if not arguments:
+        return content
+    content = content.replace("$ARGUMENTS", arguments)
+    arg_parts = arguments.split()
+    for i, arg in enumerate(arg_parts[:10]):
+        content = content.replace(f"$ARGUMENTS[{i}]", arg)
+        content = content.replace(f"${i}", arg)
+    if skill_dir:
+        content = content.replace("${SKILL_DIR}", skill_dir)
+    return content
+
+
+def _preprocess_commands(content: str) -> str:
+    """Execute !`command` inline and replace with output."""
+    def _run(match):
+        cmd = match.group(1)
+        try:
+            result = subprocess.run(
+                cmd, shell=True, capture_output=True, text=True,
+                timeout=10, cwd=str(Path.cwd()),
+            )
+            return result.stdout.strip() or result.stderr.strip() or "(no output)"
+        except subprocess.TimeoutExpired:
+            return f"[command timed out: {cmd}]"
+        except Exception as e:
+            return f"[command failed: {e}]"
+    return re.sub(r'!`([^`]+)`', _run, content)
+
+
+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 (e.g., issue number, file path)")
+
+
+class InvokeSkillResult(BaseModel):
+    skill_name: str
+    content: str
+    loaded: bool
+    forked: bool = False
+
+
+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):
+            status = "forked" if event.result.forked else "loaded"
+            return ToolResultDisplay(success=event.result.loaded, message=f"/{event.result.skill_name} ({status})")
+        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")
+
+        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]
+            raw_content = skill_info.skill_path.read_text(encoding="utf-8") if skill_info.skill_path else ""
+
+            # Strip frontmatter, keep it for metadata check
+            content = raw_content
+            meta_context = ""
+            meta_agent = ""
+            if content.startswith("---"):
+                parts = content.split("---", 2)
+                if len(parts) >= 3:
+                    # Parse context/agent from frontmatter
+                    import yaml
+                    try:
+                        fm = yaml.safe_load(parts[1]) or {}
+                        meta_context = fm.get("context", "")
+                        meta_agent = fm.get("agent", "")
+                    except Exception:
+                        pass
+                    content = parts[2].strip()
+
+            # $ARGUMENTS substitution
+            skill_dir = str(skill_info.skill_path.parent) if skill_info.skill_path else ""
+            content = _substitute_arguments(content, args.arguments, skill_dir)
+
+            # !`command` preprocessing
+            content = _preprocess_commands(content)
+
+            # If no $ARGUMENTS were in the template, prepend args
+            if args.arguments and "$ARGUMENTS" not in raw_content and "$0" not in raw_content:
+                content = f"{args.arguments}\n\n{content}"
+
+            # context: fork — run in a subagent
+            if meta_context == "fork":
+                agent_name = meta_agent or "explore"
+                # Delegate to the task tool's subagent mechanism
+                from drydock.core.agents.models import BUILTIN_AGENTS, AgentType
+                agent_profile = BUILTIN_AGENTS.get(agent_name)
+                if agent_profile and agent_profile.agent_type == AgentType.SUBAGENT:
+                    from drydock.core.agent_loop import AgentLoop
+                    from drydock.core.config import SessionLoggingConfig, VibeConfig
+
+                    session_logging = SessionLoggingConfig(
+                        save_dir=str(ctx.session_dir / "skills") if ctx.session_dir else "",
+                        session_prefix=f"skill-{args.skill_name}",
+                        enabled=ctx.session_dir is not None,
+                    )
+                    sub_config = VibeConfig.load(session_logging=session_logging)
+                    if agent_profile.model:
+                        sub_config = agent_profile.apply_to_config(sub_config)
+
+                    subagent = AgentLoop(
+                        config=sub_config,
+                        agent_name=agent_name,
+                        max_turns=agent_profile.max_turns,
+                        entrypoint_metadata=ctx.entrypoint_metadata,
+                    )
+                    if ctx.approval_callback:
+                        subagent.set_approval_callback(ctx.approval_callback)
+
+                    # Run the skill content as the subagent's task
+                    response_parts = []
+                    turns = 0
+                    async for event in subagent.run(content):
+                        from drydock.core.types import AssistantEvent
+                        if isinstance(event, AssistantEvent) and event.content:
+                            response_parts.append(event.content)
+                        turns += 1
+
+                    yield InvokeSkillResult(
+                        skill_name=args.skill_name,
+                        content="\n".join(response_parts) or "(subagent produced no output)",
+                        loaded=True,
+                        forked=True,
+                    )
+                    return
+
+            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-2.3.2/drydock/core/tools/builtins/mcp_resources.py

@@ -0,0 +1,194 @@
+"""MCP Resource tools — list and read MCP server resources.
+
+MCP servers can expose resources (files, data) in addition to tools.
+These tools let the agent discover and read them.
+"""
+
+from __future__ import annotations
+
+import asyncio
+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 ListMcpResourcesArgs(BaseModel):
+    server_name: str = Field(default="", description="MCP server name (empty = all servers)")
+
+
+class McpResource(BaseModel):
+    uri: str
+    name: str
+    description: str = ""
+    mime_type: str = ""
+    server: str = ""
+
+
+class ListMcpResourcesResult(BaseModel):
+    resources: list[McpResource]
+    count: int
+
+
+class ListMcpResources(
+    BaseTool[ListMcpResourcesArgs, ListMcpResourcesResult, BaseToolConfig, BaseToolState],
+    ToolUIData[ListMcpResourcesArgs, ListMcpResourcesResult],
+):
+    description: ClassVar[str] = "List resources available from MCP servers."
+
+    @classmethod
+    def format_call_display(cls, args: ListMcpResourcesArgs) -> ToolCallDisplay:
+        return ToolCallDisplay(summary=f"list_mcp_resources: {args.server_name or 'all'}")
+
+    @classmethod
+    def get_result_display(cls, event: ToolResultEvent) -> ToolResultDisplay:
+        if isinstance(event.result, ListMcpResourcesResult):
+            return ToolResultDisplay(success=True, message=f"{event.result.count} resources")
+        return ToolResultDisplay(success=True, message="Resources listed")
+
+    @classmethod
+    def get_status_text(cls) -> str:
+        return "Listing MCP resources"
+
+    def resolve_permission(self, args: ListMcpResourcesArgs) -> ToolPermission | None:
+        return ToolPermission.ALWAYS
+
+    @final
+    async def run(
+        self, args: ListMcpResourcesArgs, ctx: InvokeContext | None = None
+    ) -> AsyncGenerator[ToolStreamEvent | ListMcpResourcesResult, None]:
+        resources: list[McpResource] = []
+
+        try:
+            if ctx and hasattr(ctx, 'agent_manager') and ctx.agent_manager:
+                config = ctx.agent_manager.config
+                servers = config.mcp_servers or []
+
+                from drydock.core.tools.mcp.tools import (
+                    list_resources_http, list_resources_stdio,
+                )
+                from drydock.core.config import MCPStdio, MCPHttp
+
+                tasks = []
+                for srv in servers:
+                    if args.server_name and getattr(srv, 'alias', '') != args.server_name:
+                        continue
+                    if isinstance(srv, MCPHttp):
+                        tasks.append(list_resources_http(
+                            srv.url,
+                            headers=srv.headers,
+                            startup_timeout_sec=srv.startup_timeout_seconds,
+                        ))
+                    elif isinstance(srv, MCPStdio):
+                        tasks.append(list_resources_stdio(
+                            srv.command,
+                            env=srv.env,
+                            startup_timeout_sec=srv.startup_timeout_seconds,
+                        ))
+
+                if tasks:
+                    results = await asyncio.gather(*tasks, return_exceptions=True)
+                    for result in results:
+                        if isinstance(result, list):
+                            for r in result:
+                                resources.append(McpResource(
+                                    uri=r.uri, name=r.name,
+                                    description=r.description,
+                                    mime_type=r.mime_type,
+                                    server=r.server,
+                                ))
+        except Exception as e:
+            raise ToolError(f"Failed to list MCP resources: {e}") from e
+
+        yield ListMcpResourcesResult(resources=resources, count=len(resources))
+
+
+class ReadMcpResourceArgs(BaseModel):
+    uri: str = Field(description="Resource URI to read")
+    server_name: str = Field(default="", description="MCP server name (required if multiple servers)")
+
+
+class ReadMcpResourceResult(BaseModel):
+    uri: str
+    content: str
+    mime_type: str = ""
+
+
+class ReadMcpResource(
+    BaseTool[ReadMcpResourceArgs, ReadMcpResourceResult, BaseToolConfig, BaseToolState],
+    ToolUIData[ReadMcpResourceArgs, ReadMcpResourceResult],
+):
+    description: ClassVar[str] = "Read a resource from an MCP server by URI."
+
+    @classmethod
+    def format_call_display(cls, args: ReadMcpResourceArgs) -> ToolCallDisplay:
+        return ToolCallDisplay(summary=f"read_mcp_resource: {args.uri[:50]}")
+
+    @classmethod
+    def get_result_display(cls, event: ToolResultEvent) -> ToolResultDisplay:
+        return ToolResultDisplay(success=True, message="Resource read")
+
+    @classmethod
+    def get_status_text(cls) -> str:
+        return "Reading MCP resource"
+
+    def resolve_permission(self, args: ReadMcpResourceArgs) -> ToolPermission | None:
+        return ToolPermission.ALWAYS
+
+    @final
+    async def run(
+        self, args: ReadMcpResourceArgs, ctx: InvokeContext | None = None
+    ) -> AsyncGenerator[ToolStreamEvent | ReadMcpResourceResult, None]:
+        if not ctx or not hasattr(ctx, 'agent_manager') or not ctx.agent_manager:
+            raise ToolError("No agent manager available for MCP resource reading")
+
+        config = ctx.agent_manager.config
+        servers = config.mcp_servers or []
+
+        if not servers:
+            raise ToolError("No MCP servers configured. Add servers to ~/.drydock/config.toml")
+
+        from drydock.core.tools.mcp.tools import read_resource_http, read_resource_stdio
+        from drydock.core.config import MCPStdio, MCPHttp
+
+        # Try each server until we find the resource
+        last_error = None
+        for srv in servers:
+            if args.server_name and getattr(srv, 'alias', '') != args.server_name:
+                continue
+            try:
+                if isinstance(srv, MCPHttp):
+                    content = await read_resource_http(
+                        srv.url, args.uri,
+                        headers=srv.headers,
+                        startup_timeout_sec=srv.startup_timeout_seconds,
+                    )
+                elif isinstance(srv, MCPStdio):
+                    content = await read_resource_stdio(
+                        srv.command, args.uri,
+                        env=srv.env,
+                        startup_timeout_sec=srv.startup_timeout_seconds,
+                    )
+                else:
+                    continue
+
+                yield ReadMcpResourceResult(
+                    uri=args.uri,
+                    content=content,
+                    mime_type="",
+                )
+                return
+            except Exception as e:
+                last_error = e
+                continue
+
+        raise ToolError(
+            f"Could not read resource '{args.uri}' from any MCP server. "
+            f"Last error: {last_error}"
+        )

{drydock_cli-2.3.0 → drydock_cli-2.3.2}/drydock/core/tools/mcp/tools.py

@@ -410,3 +410,109 @@ def create_mcp_stdio_proxy_tool_class(
 
     MCPStdioProxyTool.__name__ = f"MCP_STDIO_{computed_alias}__{remote.name}"
     return MCPStdioProxyTool
+
+
+# ── MCP Resource listing/reading ─────────────────────────────────────────
+
+class MCPResource:
+    """Simple container for an MCP resource."""
+    def __init__(self, uri: str, name: str, description: str = "", mime_type: str = "", server: str = ""):
+        self.uri = uri
+        self.name = name
+        self.description = description
+        self.mime_type = mime_type
+        self.server = server
+
+
+async def list_resources_http(
+    url: str,
+    *,
+    headers: dict[str, str] | None = None,
+    startup_timeout_sec: float | None = None,
+) -> list[MCPResource]:
+    timeout = timedelta(seconds=startup_timeout_sec) if startup_timeout_sec else None
+    async with streamablehttp_client(url, headers=headers) as (read, write, _):
+        async with ClientSession(read, write, read_timeout_seconds=timeout) as session:
+            await session.initialize()
+            resp = await session.list_resources()
+            return [
+                MCPResource(
+                    uri=str(r.uri), name=r.name,
+                    description=getattr(r, 'description', '') or '',
+                    mime_type=getattr(r, 'mimeType', '') or '',
+                    server=url,
+                )
+                for r in resp.resources
+            ]
+
+
+async def list_resources_stdio(
+    command: list[str],
+    *,
+    env: dict[str, str] | None = None,
+    startup_timeout_sec: float | None = None,
+) -> list[MCPResource]:
+    params = StdioServerParameters(command=command[0], args=command[1:], env=env)
+    timeout = timedelta(seconds=startup_timeout_sec) if startup_timeout_sec else None
+    async with (
+        _mcp_stderr_capture() as errlog,
+        stdio_client(params, errlog=errlog) as (read, write),
+        ClientSession(read, write, read_timeout_seconds=timeout) as session,
+    ):
+        await session.initialize()
+        resp = await session.list_resources()
+        return [
+            MCPResource(
+                uri=str(r.uri), name=r.name,
+                description=getattr(r, 'description', '') or '',
+                mime_type=getattr(r, 'mimeType', '') or '',
+                server=" ".join(command),
+            )
+            for r in resp.resources
+        ]
+
+
+async def read_resource_http(
+    url: str,
+    resource_uri: str,
+    *,
+    headers: dict[str, str] | None = None,
+    startup_timeout_sec: float | None = None,
+) -> str:
+    timeout = timedelta(seconds=startup_timeout_sec) if startup_timeout_sec else None
+    async with streamablehttp_client(url, headers=headers) as (read, write, _):
+        async with ClientSession(read, write, read_timeout_seconds=timeout) as session:
+            await session.initialize()
+            resp = await session.read_resource(resource_uri)
+            parts = []
+            for content in resp.contents:
+                if hasattr(content, 'text'):
+                    parts.append(content.text)
+                elif hasattr(content, 'blob'):
+                    parts.append(f"[binary data: {len(content.blob)} bytes]")
+            return "\n".join(parts)
+
+
+async def read_resource_stdio(
+    command: list[str],
+    resource_uri: str,
+    *,
+    env: dict[str, str] | None = None,
+    startup_timeout_sec: float | None = None,
+) -> str:
+    params = StdioServerParameters(command=command[0], args=command[1:], env=env)
+    timeout = timedelta(seconds=startup_timeout_sec) if startup_timeout_sec else None
+    async with (
+        _mcp_stderr_capture() as errlog,
+        stdio_client(params, errlog=errlog) as (read, write),
+        ClientSession(read, write, read_timeout_seconds=timeout) as session,
+    ):
+        await session.initialize()
+        resp = await session.read_resource(resource_uri)
+        parts = []
+        for content in resp.contents:
+            if hasattr(content, 'text'):
+                parts.append(content.text)
+            elif hasattr(content, 'blob'):
+                parts.append(f"[binary data: {len(content.blob)} bytes]")
+        return "\n".join(parts)

drydock_cli-2.3.2/drydock/skills/api-design/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: api-design
+description: Design and review REST/GraphQL APIs. Schema validation, endpoint design, error handling patterns.
+allowed-tools: read_file grep glob write_file bash
+user-invocable: true
+---
+
+# API Design Review
+
+Analyze or design an API ($ARGUMENTS).
+
+## For existing APIs:
+1. Find route/endpoint definitions
+2. Check for consistency in naming, HTTP methods, status codes
+3. Verify error handling and validation
+4. Check authentication/authorization
+5. Review request/response schemas
+
+## For new APIs:
+1. Define resources and relationships
+2. Design endpoints following REST conventions
+3. Define request/response schemas
+4. Plan error codes and messages
+5. Generate OpenAPI/Swagger spec if requested
+
+## Best Practices
+- Use plural nouns for resources (/users, not /user)
+- Use HTTP methods correctly (GET=read, POST=create, PUT=update, DELETE=delete)
+- Return appropriate status codes (201 for create, 204 for delete)
+- Use consistent error format: `{"error": {"code": "...", "message": "..."}}`
+- Version the API (/v1/, /v2/)
+- Paginate list endpoints

drydock_cli-2.3.2/drydock/skills/commit-code/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: commit-code
+description: Create a git commit with a well-crafted message. Stages changes, reviews diff, writes conventional commit.
+allowed-tools: bash read_file grep
+user-invocable: true
+---
+
+# Commit Workflow
+
+1. Run `git status` and `git diff --stat` to see what changed
+2. Run `git diff` to read the actual changes (limit to 200 lines)
+3. Write a commit message following conventional commits:
+   - `fix:` for bug fixes
+   - `feat:` for new features
+   - `refactor:` for refactoring
+   - `docs:` for documentation
+   - `test:` for test changes
+   - `chore:` for maintenance
+4. Stage relevant files with `git add` (specific files, not -A)
+5. Create the commit with `git commit -m "message"`
+6. Show `git log --oneline -3` to confirm
+
+Rules:
+- NEVER commit .env, credentials, or secrets
+- Keep the first line under 72 characters
+- Add a body if the change is complex
+- If $ARGUMENTS is provided, use it as context for the commit message

drydock_cli-2.3.2/drydock/skills/context-summary/SKILL.md

@@ -0,0 +1,19 @@
+---
+name: context-summary
+description: Summarize the current session context. What files were read, edited, what's the current state.
+allowed-tools: bash read_file
+user-invocable: true
+---
+
+# Context Summary
+
+Produce a summary of the current working state:
+
+1. **Git status**: `git status --short`
+2. **Recent changes**: `git diff --stat`
+3. **Recent commits**: `git log --oneline -5`
+4. **Modified files**: List files changed in this session
+5. **Current task**: What was the user's original request?
+6. **Progress**: What's been done, what remains?
+
+Output as a clean summary the user can quickly scan.

drydock_cli-2.3.2/drydock/skills/deploy/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: deploy
+description: Deployment workflow. Build, test, tag, push, deploy. Supports PyPI, Docker, GitHub releases.
+allowed-tools: bash read_file grep
+user-invocable: true
+---
+
+# Deployment Workflow
+
+## Steps
+1. Run tests: `python -m pytest -x -q`
+2. Check version in pyproject.toml or setup.py
+3. Build: `python -m build` or `docker build .`
+4. Deploy based on target ($ARGUMENTS):
+   - **pypi**: `twine upload dist/*`
+   - **docker**: `docker push`
+   - **github**: `gh release create`
+   - **server**: `rsync` or `ssh` deploy
+5. Tag: `git tag vX.Y.Z && git push --tags`
+6. Notify: output deployment summary
+
+## Rules
+- ALWAYS run tests before deploying
+- NEVER deploy with uncommitted changes
+- Check that version was bumped
+- Verify the deployment succeeded

drydock_cli-2.3.2/drydock/skills/diff-review/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: diff-review
+description: Show and analyze uncommitted changes. Summarize what changed and why.
+allowed-tools: bash read_file
+user-invocable: true
+---
+
+# Diff Review
+
+1. Show uncommitted changes: `git diff --stat`
+2. Show the full diff: `git diff`
+3. For each changed file, analyze:
+   - What was the intent of the change?
+   - Is the change correct and complete?
+   - Any issues or improvements?
+4. Provide a summary suitable for a commit message