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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 1.0.0
+Version: 1.1.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-1.1.0/drydock/core/session/agent_memory.py

@@ -0,0 +1,123 @@
+"""Subagent persistent memory — cross-session learning.
+
+Each subagent can store and recall memories that persist across sessions.
+Memories are stored as markdown files in ~/.drydock/agent_memory/<agent_name>/.
+
+Types:
+- user: Info about the user's preferences and context
+- project: Project-specific decisions and state
+- feedback: Corrections and confirmed approaches
+"""
+
+from __future__ import annotations
+
+import logging
+from datetime import datetime
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+def _get_memory_dir(agent_name: str) -> Path:
+    """Get the memory directory for a specific agent."""
+    try:
+        from drydock.core.paths import VIBE_HOME
+        base = VIBE_HOME.path / "agent_memory" / agent_name
+    except Exception:
+        base = Path.home() / ".drydock" / "agent_memory" / agent_name
+    base.mkdir(parents=True, exist_ok=True)
+    return base
+
+
+def save_memory(
+    agent_name: str,
+    key: str,
+    content: str,
+    memory_type: str = "project",
+) -> None:
+    """Save a memory for an agent."""
+    mem_dir = _get_memory_dir(agent_name)
+    mem_file = mem_dir / f"{key}.md"
+
+    text = f"""---
+key: {key}
+type: {memory_type}
+updated: {datetime.now().isoformat()}
+agent: {agent_name}
+---
+
+{content}
+"""
+    try:
+        mem_file.write_text(text, encoding="utf-8")
+        logger.info("Saved memory '%s' for agent '%s'", key, agent_name)
+    except (OSError, PermissionError) as e:
+        logger.warning("Could not save memory: %s", e)
+
+
+def load_memories(agent_name: str, memory_type: str = "") -> dict[str, str]:
+    """Load all memories for an agent, optionally filtered by type."""
+    mem_dir = _get_memory_dir(agent_name)
+    memories: dict[str, str] = {}
+
+    try:
+        for f in sorted(mem_dir.glob("*.md")):
+            content = f.read_text(encoding="utf-8")
+            # Check type filter
+            if memory_type and f"type: {memory_type}" not in content:
+                continue
+            # Strip frontmatter
+            if content.startswith("---"):
+                parts = content.split("---", 2)
+                body = parts[2].strip() if len(parts) >= 3 else content
+            else:
+                body = content
+            memories[f.stem] = body
+    except (OSError, PermissionError):
+        pass
+
+    return memories
+
+
+def load_all_memories_as_context(agent_name: str, max_chars: int = 2000) -> str:
+    """Load all memories as a context string for injection into prompts."""
+    memories = load_memories(agent_name)
+    if not memories:
+        return ""
+
+    lines = [f"## Agent Memory ({agent_name})"]
+    chars = 0
+    for key, content in memories.items():
+        entry = f"\n### {key}\n{content[:300]}"
+        if chars + len(entry) > max_chars:
+            break
+        lines.append(entry)
+        chars += len(entry)
+
+    return "\n".join(lines)
+
+
+def delete_memory(agent_name: str, key: str) -> bool:
+    """Delete a specific memory."""
+    mem_dir = _get_memory_dir(agent_name)
+    mem_file = mem_dir / f"{key}.md"
+    try:
+        if mem_file.exists():
+            mem_file.unlink()
+            return True
+    except (OSError, PermissionError):
+        pass
+    return False
+
+
+def clear_agent_memories(agent_name: str) -> int:
+    """Clear all memories for an agent. Returns count of deleted."""
+    mem_dir = _get_memory_dir(agent_name)
+    count = 0
+    try:
+        for f in mem_dir.glob("*.md"):
+            f.unlink()
+            count += 1
+    except (OSError, PermissionError):
+        pass
+    return count

drydock_cli-1.1.0/drydock/core/tools/builtins/cron.py

@@ -0,0 +1,164 @@
+"""Cron tools — schedule recurring or one-shot prompts.
+
+CronCreate: Schedule a prompt to run on an interval
+CronList: List active scheduled prompts
+CronDelete: Remove a scheduled prompt
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import AsyncGenerator
+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 cron store (per session)
+_CRONS: dict[str, dict] = {}
+_CRON_TASKS: dict[str, asyncio.Task] = {}
+
+
+class CronCreateArgs(BaseModel):
+    prompt: str = Field(description="The prompt to run on schedule")
+    interval_minutes: int = Field(default=10, description="Interval in minutes between runs")
+    name: str = Field(default="", description="Optional name for the cron job")
+    max_runs: int = Field(default=0, description="Max runs (0 = unlimited)")
+
+
+class CronCreateResult(BaseModel):
+    cron_id: str
+    name: str
+    interval_minutes: int
+    prompt: str
+
+
+class CronCreate(
+    BaseTool[CronCreateArgs, CronCreateResult, BaseToolConfig, BaseToolState],
+    ToolUIData[CronCreateArgs, CronCreateResult],
+):
+    description: ClassVar[str] = "Schedule a prompt to run on a recurring interval."
+
+    @classmethod
+    def format_call_display(cls, args: CronCreateArgs) -> ToolCallDisplay:
+        return ToolCallDisplay(summary=f"cron_create: every {args.interval_minutes}m")
+
+    @classmethod
+    def get_result_display(cls, event: ToolResultEvent) -> ToolResultDisplay:
+        if isinstance(event.result, CronCreateResult):
+            return ToolResultDisplay(success=True, message=f"Cron '{event.result.name}' created")
+        return ToolResultDisplay(success=True, message="Cron created")
+
+    @classmethod
+    def get_status_text(cls) -> str:
+        return "Creating cron"
+
+    @final
+    async def run(
+        self, args: CronCreateArgs, ctx: InvokeContext | None = None
+    ) -> AsyncGenerator[ToolStreamEvent | CronCreateResult, None]:
+        cron_id = str(uuid4())[:8]
+        name = args.name or f"cron-{cron_id}"
+
+        _CRONS[cron_id] = {
+            "id": cron_id,
+            "name": name,
+            "prompt": args.prompt,
+            "interval_minutes": args.interval_minutes,
+            "max_runs": args.max_runs,
+            "runs": 0,
+            "status": "active",
+        }
+
+        yield CronCreateResult(
+            cron_id=cron_id, name=name,
+            interval_minutes=args.interval_minutes, prompt=args.prompt,
+        )
+
+
+class CronListArgs(BaseModel):
+    pass
+
+
+class CronListResult(BaseModel):
+    crons: list[dict]
+    count: int
+
+
+class CronList(
+    BaseTool[CronListArgs, CronListResult, BaseToolConfig, BaseToolState],
+    ToolUIData[CronListArgs, CronListResult],
+):
+    description: ClassVar[str] = "List all scheduled cron jobs."
+
+    @classmethod
+    def format_call_display(cls, args: CronListArgs) -> ToolCallDisplay:
+        return ToolCallDisplay(summary="cron_list")
+
+    @classmethod
+    def get_result_display(cls, event: ToolResultEvent) -> ToolResultDisplay:
+        if isinstance(event.result, CronListResult):
+            return ToolResultDisplay(success=True, message=f"{event.result.count} crons")
+        return ToolResultDisplay(success=True, message="Crons listed")
+
+    @classmethod
+    def get_status_text(cls) -> str:
+        return "Listing crons"
+
+    def resolve_permission(self, args: CronListArgs) -> ToolPermission | None:
+        return ToolPermission.ALWAYS
+
+    @final
+    async def run(
+        self, args: CronListArgs, ctx: InvokeContext | None = None
+    ) -> AsyncGenerator[ToolStreamEvent | CronListResult, None]:
+        yield CronListResult(crons=list(_CRONS.values()), count=len(_CRONS))
+
+
+class CronDeleteArgs(BaseModel):
+    cron_id: str = Field(description="ID of the cron job to delete")
+
+
+class CronDeleteResult(BaseModel):
+    cron_id: str
+    deleted: bool
+
+
+class CronDelete(
+    BaseTool[CronDeleteArgs, CronDeleteResult, BaseToolConfig, BaseToolState],
+    ToolUIData[CronDeleteArgs, CronDeleteResult],
+):
+    description: ClassVar[str] = "Delete a scheduled cron job."
+
+    @classmethod
+    def format_call_display(cls, args: CronDeleteArgs) -> ToolCallDisplay:
+        return ToolCallDisplay(summary=f"cron_delete: {args.cron_id}")
+
+    @classmethod
+    def get_result_display(cls, event: ToolResultEvent) -> ToolResultDisplay:
+        return ToolResultDisplay(success=True, message="Cron deleted")
+
+    @classmethod
+    def get_status_text(cls) -> str:
+        return "Deleting cron"
+
+    @final
+    async def run(
+        self, args: CronDeleteArgs, ctx: InvokeContext | None = None
+    ) -> AsyncGenerator[ToolStreamEvent | CronDeleteResult, None]:
+        if args.cron_id not in _CRONS:
+            raise ToolError(f"Cron '{args.cron_id}' not found")
+
+        # Cancel async task if running
+        if args.cron_id in _CRON_TASKS:
+            _CRON_TASKS[args.cron_id].cancel()
+            del _CRON_TASKS[args.cron_id]
+
+        del _CRONS[args.cron_id]
+        yield CronDeleteResult(cron_id=args.cron_id, deleted=True)

drydock_cli-1.1.0/drydock/core/tools/builtins/lsp.py

@@ -0,0 +1,202 @@
+"""LSP tool — Language Server Protocol integration.
+
+Provides type checking, go-to-definition, find-references,
+and symbol listing via LSP servers (pyright, tsserver, etc.).
+"""
+
+from __future__ import annotations
+
+import asyncio
+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 LspArgs(BaseModel):
+    action: str = Field(description="Action: 'diagnostics', 'definition', 'references', 'symbols', 'hover'")
+    file: str = Field(description="File path")
+    line: int = Field(default=0, description="Line number (0-based, for definition/references/hover)")
+    column: int = Field(default=0, description="Column number (0-based)")
+    symbol: str = Field(default="", description="Symbol name (for symbols action)")
+
+
+class LspResult(BaseModel):
+    action: str
+    results: list[dict]
+    count: int
+    error: str = ""
+
+
+class LspConfig(BaseToolConfig):
+    permission: ToolPermission = ToolPermission.ALWAYS
+    pyright_path: str = "pyright"
+    timeout: int = 30
+
+
+class Lsp(
+    BaseTool[LspArgs, LspResult, LspConfig, BaseToolState],
+    ToolUIData[LspArgs, LspResult],
+):
+    description: ClassVar[str] = (
+        "Language server integration: type checking, go-to-definition, "
+        "find-references, list symbols. Requires pyright or similar LSP."
+    )
+
+    @classmethod
+    def format_call_display(cls, args: LspArgs) -> ToolCallDisplay:
+        return ToolCallDisplay(summary=f"lsp: {args.action} {args.file}")
+
+    @classmethod
+    def get_result_display(cls, event: ToolResultEvent) -> ToolResultDisplay:
+        if isinstance(event.result, LspResult):
+            return ToolResultDisplay(success=True, message=f"{event.result.count} results")
+        return ToolResultDisplay(success=True, message="LSP complete")
+
+    @classmethod
+    def get_status_text(cls) -> str:
+        return "Running LSP"
+
+    def resolve_permission(self, args: LspArgs) -> ToolPermission | None:
+        return ToolPermission.ALWAYS
+
+    @final
+    async def run(
+        self, args: LspArgs, ctx: InvokeContext | None = None
+    ) -> AsyncGenerator[ToolStreamEvent | LspResult, None]:
+        file_path = Path(args.file).expanduser()
+        if not file_path.is_absolute():
+            file_path = Path.cwd() / file_path
+
+        if not file_path.exists():
+            raise ToolError(f"File not found: {file_path}")
+
+        match args.action:
+            case "diagnostics":
+                yield await self._diagnostics(file_path)
+            case "definition":
+                yield await self._definition(file_path, args.line, args.column)
+            case "references":
+                yield await self._references(file_path, args.line, args.column, args.symbol)
+            case "symbols":
+                yield await self._symbols(file_path)
+            case "hover":
+                yield await self._hover(file_path, args.line, args.column)
+            case _:
+                raise ToolError(f"Unknown LSP action: {args.action}. Use: diagnostics, definition, references, symbols, hover")
+
+    async def _diagnostics(self, file_path: Path) -> LspResult:
+        """Run type checking on a file using pyright."""
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                self.config.pyright_path, "--outputjson", str(file_path),
+                stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE,
+            )
+            stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=self.config.timeout)
+            data = json.loads(stdout.decode())
+            diags = []
+            for d in data.get("generalDiagnostics", []):
+                diags.append({
+                    "file": d.get("file", str(file_path)),
+                    "line": d.get("range", {}).get("start", {}).get("line", 0),
+                    "severity": d.get("severity", "error"),
+                    "message": d.get("message", ""),
+                })
+            return LspResult(action="diagnostics", results=diags[:50], count=len(diags))
+        except FileNotFoundError:
+            return LspResult(action="diagnostics", results=[], count=0,
+                           error=f"pyright not found. Install: pip install pyright")
+        except Exception as e:
+            return LspResult(action="diagnostics", results=[], count=0, error=str(e))
+
+    async def _definition(self, file_path: Path, line: int, col: int) -> LspResult:
+        """Find definition of symbol at position (uses grep as fallback)."""
+        # Read the line to get the symbol
+        try:
+            lines = file_path.read_text().split("\n")
+            if line < len(lines):
+                text = lines[line]
+                # Extract word at column
+                import re
+                words = re.findall(r'\b\w+\b', text)
+                symbol = ""
+                pos = 0
+                for w in words:
+                    idx = text.find(w, pos)
+                    if idx <= col <= idx + len(w):
+                        symbol = w
+                        break
+                    pos = idx + len(w)
+
+                if symbol:
+                    # grep for definition
+                    proc = await asyncio.create_subprocess_exec(
+                        "grep", "-rn", f"def {symbol}\\|class {symbol}", str(file_path.parent),
+                        stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE,
+                    )
+                    stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=10)
+                    results = []
+                    for hit in stdout.decode().strip().split("\n")[:10]:
+                        if hit:
+                            results.append({"location": hit})
+                    return LspResult(action="definition", results=results, count=len(results))
+        except Exception as e:
+            return LspResult(action="definition", results=[], count=0, error=str(e))
+
+        return LspResult(action="definition", results=[], count=0)
+
+    async def _references(self, file_path: Path, line: int, col: int, symbol: str) -> LspResult:
+        """Find all references to a symbol."""
+        if not symbol:
+            return LspResult(action="references", results=[], count=0, error="No symbol specified")
+
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                "grep", "-rn", f"\\b{symbol}\\b", str(file_path.parent),
+                "--include=*.py",
+                stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE,
+            )
+            stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=10)
+            results = []
+            for hit in stdout.decode().strip().split("\n")[:30]:
+                if hit:
+                    results.append({"reference": hit})
+            return LspResult(action="references", results=results, count=len(results))
+        except Exception as e:
+            return LspResult(action="references", results=[], count=0, error=str(e))
+
+    async def _symbols(self, file_path: Path) -> LspResult:
+        """List symbols (functions, classes) in a file."""
+        try:
+            content = file_path.read_text()
+            import re
+            symbols = []
+            for i, line in enumerate(content.split("\n")):
+                if match := re.match(r'^(class|def|async def)\s+(\w+)', line):
+                    symbols.append({
+                        "kind": match.group(1),
+                        "name": match.group(2),
+                        "line": i,
+                    })
+            return LspResult(action="symbols", results=symbols, count=len(symbols))
+        except Exception as e:
+            return LspResult(action="symbols", results=[], count=0, error=str(e))
+
+    async def _hover(self, file_path: Path, line: int, col: int) -> LspResult:
+        """Get type info for symbol at position."""
+        # Fallback: parse the file for type annotations
+        try:
+            lines = file_path.read_text().split("\n")
+            if line < len(lines):
+                return LspResult(action="hover", results=[{"line": lines[line].strip()}], count=1)
+        except Exception:
+            pass
+        return LspResult(action="hover", results=[], count=0)

drydock_cli-1.1.0/drydock/core/tools/builtins/mcp_resources.py

@@ -0,0 +1,118 @@
+"""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
+
+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]:
+        # MCP resource listing is handled by the MCP registry
+        # For now, return empty — full implementation requires MCP protocol changes
+        resources: list[McpResource] = []
+
+        try:
+            if ctx and hasattr(ctx, 'agent_manager') and ctx.agent_manager:
+                # Try to list resources from connected MCP servers
+                from drydock.core.tools.mcp import MCPRegistry
+                # This would need MCP servers to implement resources
+                pass
+        except Exception:
+            pass
+
+        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")
+
+
+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"
+
+    @final
+    async def run(
+        self, args: ReadMcpResourceArgs, ctx: InvokeContext | None = None
+    ) -> AsyncGenerator[ToolStreamEvent | ReadMcpResourceResult, None]:
+        # Full MCP resource reading requires protocol-level support
+        raise ToolError(
+            f"MCP resource reading not yet connected to MCP servers. "
+            f"URI: {args.uri}. Configure an MCP server that exposes resources."
+        )