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

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

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