drydock-cli 2.2.9__tar.gz → 2.3.1__tar.gz

{drydock_cli-2.2.9 → drydock_cli-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.2.9
+Version: 2.3.1
 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.2.9 → drydock_cli-2.3.1}/drydock/core/agent_loop.py

@@ -2053,30 +2053,28 @@ class AgentLoop:
         except Exception:
             pass
 
-        # 2. Skill routing: match prompt to skill and inject content
-        skill_name = None
-        if any(kw in msg_lower for kw in ("review this", "review the", "code review", "audit")):
-            skill_name = "review"
-        elif any(kw in msg_lower for kw in ("investigate", "debug", "why does", "why is", "broken", "diagnose")):
-            skill_name = "investigate"
-        elif any(kw in msg_lower for kw in ("ship it", "commit and push", "create a pr", "open a pr")):
-            skill_name = "ship"
-        elif any(kw in msg_lower for kw in ("simplify", "clean up", "reduce complexity")):
-            skill_name = "simplify"
+        # 2. Skill discovery: inject all skill descriptions so the model
+        # can decide when to use them (replaces hardcoded keyword matching)
+        try:
+            skill_descriptions = []
+            for name, info in self.skill_manager.list_skills().items():
+                desc = info.description or name
+                skill_descriptions.append(f"  /{name} — {desc[:100]}")
+            if skill_descriptions:
+                parts.append(
+                    "AVAILABLE SKILLS (use invoke_skill to activate):\n"
+                    + "\n".join(skill_descriptions[:10])
+                )
+        except Exception:
+            pass
 
-        if skill_name:
-            skill_info = self.skill_manager.get_skill(skill_name)
-            if skill_info and skill_info.skill_path:
-                try:
-                    content = skill_info.skill_path.read_text(encoding="utf-8")
-                    # Strip frontmatter
-                    if content.startswith("---"):
-                        end = content.find("---", 3)
-                        if end > 0:
-                            content = content[end + 3:].strip()
-                    parts.append(f"FOLLOW THIS WORKFLOW ({skill_name} skill):\n{content[:2000]}")
-                except Exception:
-                    pass
+        # 3. Subagent descriptions for delegation
+        parts.append(
+            "SUBAGENTS (use task tool to delegate):\n"
+            "  task(task='...', agent='explore') — Read-only codebase exploration\n"
+            "  task(task='...', agent='diagnostic') — Debug/investigate with bash access\n"
+            "  task(task='...', agent='planner') — Plan multi-file changes before coding"
+        )
 
         # 3. Planning nudge for complex build tasks
         is_build = any(kw in msg_lower for kw in (

{drydock_cli-2.2.9 → drydock_cli-2.3.1}/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.1/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.1/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.2.9 → drydock_cli-2.3.1}/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.2.9 → drydock_cli-2.3.1}/pyproject.toml

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