drydock-cli 1.2.1__tar.gz → 1.3.1__tar.gz

{drydock_cli-1.2.1 → drydock_cli-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 1.2.1
+Version: 1.3.1
 Summary: Drydock — nautical CLI coding agent
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock
@@ -39,6 +39,7 @@ Requires-Dist: packaging>=24.1
 Requires-Dist: pexpect>=4.9.0
 Requires-Dist: pydantic-settings>=2.12.0
 Requires-Dist: pydantic>=2.12.4
+Requires-Dist: pypdf>=4.0.0
 Requires-Dist: pyperclip>=1.11.0
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: pyyaml>=6.0.0

{drydock_cli-1.2.1 → drydock_cli-1.3.1}/drydock/cli/entrypoint.py

@@ -69,6 +69,11 @@ def parse_arguments() -> argparse.Namespace:
         "for human-readable (default), 'json' for all messages at end, "
         "'streaming' for newline-delimited JSON per message.",
     )
+    parser.add_argument(
+        "--json-schema",
+        metavar="FILE",
+        help="Path to JSON Schema file. Constrains the final output to match the schema.",
+    )
     parser.add_argument(
         "--agent",
         metavar="NAME",

{drydock_cli-1.2.1 → drydock_cli-1.3.1}/drydock/core/agent_loop.py

@@ -562,6 +562,23 @@ class AgentLoop:
                                     except (json.JSONDecodeError, AttributeError):
                                         edit_path = ""
 
+                                    # Auto-run diagnostics on edited Python files
+                                    if edit_path and edit_path.endswith(".py"):
+                                        try:
+                                            import asyncio
+                                            import subprocess
+                                            diag_result = subprocess.run(
+                                                ["python3", "-c", f"import ast; ast.parse(open('{edit_path}').read()); print('OK')"],
+                                                capture_output=True, text=True, timeout=5,
+                                            )
+                                            if diag_result.returncode != 0:
+                                                self._inject_system_note(
+                                                    f"SYNTAX ERROR in {edit_path}: {diag_result.stderr.strip()[:200]}. "
+                                                    f"Fix the syntax error before continuing."
+                                                )
+                                        except Exception:
+                                            pass
+
                                     # After first edit: prompt to check related files
                                     if first_edit and edit_path:
                                         self._inject_system_note(

{drydock_cli-1.2.1 → drydock_cli-1.3.1}/drydock/core/agents/models.py

@@ -178,20 +178,28 @@ AUTO_APPROVE = AgentProfile(
 EXPLORE = AgentProfile(
     name=BuiltinAgentName.EXPLORE,
     display_name="Explore",
-    description="Read-only subagent for codebase exploration",
+    description=(
+        "Read-only subagent for codebase exploration. Use when you need to "
+        "understand a project with 3+ files, map architecture, or find where "
+        "a function/class is defined. Has grep and read_file only — cannot edit."
+    ),
     safety=AgentSafety.SAFE,
     agent_type=AgentType.SUBAGENT,
-    overrides={"enabled_tools": ["grep", "read_file"], "system_prompt_id": "explore"},
+    overrides={"enabled_tools": ["grep", "read_file", "glob"], "system_prompt_id": "explore"},
 )
 
 DIAGNOSTIC = AgentProfile(
     name=BuiltinAgentName.DIAGNOSTIC,
     display_name="Diagnostic",
-    description="Subagent that analyzes test failures and suggests fixes",
+    description=(
+        "Subagent that analyzes test failures, error traces, and runtime issues. "
+        "Use when tests fail and you need to understand WHY before fixing. "
+        "Can run tests via bash and read source code."
+    ),
     safety=AgentSafety.SAFE,
     agent_type=AgentType.SUBAGENT,
     overrides={
-        "enabled_tools": ["grep", "read_file", "bash"],
+        "enabled_tools": ["grep", "read_file", "bash", "glob"],
         "system_prompt_id": "diagnostic",
     },
 )
@@ -199,11 +207,15 @@ DIAGNOSTIC = AgentProfile(
 PLANNER = AgentProfile(
     name=BuiltinAgentName.PLANNER,
     display_name="Planner",
-    description="Read-only subagent that analyzes bugs and identifies target files",
+    description=(
+        "Read-only subagent that creates implementation plans before coding. "
+        "Use for complex changes that touch multiple modules — the planner "
+        "identifies target files, dependencies, and change order."
+    ),
     safety=AgentSafety.SAFE,
     agent_type=AgentType.SUBAGENT,
     overrides={
-        "enabled_tools": ["grep", "read_file"],
+        "enabled_tools": ["grep", "read_file", "glob"],
         "system_prompt_id": "planner",
     },
 )

{drydock_cli-1.2.1 → drydock_cli-1.3.1}/drydock/core/config/harness_files/_harness_manager.py

@@ -65,11 +65,21 @@ class HarnessFilesManager:
         bundled = VIBE_ROOT / "skills"
         if bundled.is_dir():
             dirs.append(bundled)
+        # Project skills in .drydock/skills/ (current directory)
+        project_skills = Path.cwd() / ".drydock" / "skills"
+        if project_skills.is_dir():
+            dirs.append(project_skills)
         # User skills in ~/.drydock/skills/
         if "user" in self.sources:
             d = GLOBAL_SKILLS_DIR.path
             if d.is_dir():
                 dirs.append(d)
+        # Plugin skills
+        try:
+            from drydock.core.plugins import get_plugin_skill_dirs
+            dirs.extend(get_plugin_skill_dirs())
+        except Exception:
+            pass
         return dirs
 
     @property

{drydock_cli-1.2.1 → drydock_cli-1.3.1}/drydock/core/hooks.py

@@ -40,10 +40,19 @@ logger = logging.getLogger(__name__)
 class HookEvent(StrEnum):
     PRE_TOOL_USE = auto()
     POST_TOOL_USE = auto()
+    POST_TOOL_USE_FAILURE = auto()
     SESSION_START = auto()
     SESSION_END = auto()
     PRE_EDIT = auto()
     POST_EDIT = auto()
+    USER_PROMPT_SUBMIT = auto()
+    STOP = auto()
+    FILE_CHANGED = auto()
+    CWD_CHANGED = auto()
+    PRE_COMPACT = auto()
+    POST_COMPACT = auto()
+    SUBAGENT_START = auto()
+    SUBAGENT_STOP = auto()
 
 
 class HookDecision(StrEnum):

drydock_cli-1.3.1/drydock/core/plugins.py

@@ -0,0 +1,138 @@
+"""Plugin system for DryDock.
+
+Plugins are directories with a plugin.json manifest that can provide:
+- skills/ — Skill definitions (SKILL.md files)
+- agents/ — Agent profiles (TOML or Markdown)
+- hooks/ — Hook scripts
+
+Install: drydock plugin install <path-or-url>
+Location: ~/.drydock/plugins/<name>/
+
+plugin.json format:
+{
+    "name": "my-plugin",
+    "version": "1.0.0",
+    "description": "What this plugin does",
+    "author": "Name",
+    "skills": ["skill-name"],
+    "agents": ["agent-name"],
+    "hooks": ["hook-config.json"]
+}
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class PluginInfo:
+    name: str
+    version: str
+    description: str
+    path: Path
+    skills: list[str]
+    agents: list[str]
+
+
+def _plugins_dir() -> Path:
+    """Get the plugins directory."""
+    try:
+        from drydock.core.paths import VIBE_HOME
+        return VIBE_HOME.path / "plugins"
+    except Exception:
+        return Path.home() / ".drydock" / "plugins"
+
+
+def list_plugins() -> list[PluginInfo]:
+    """List all installed plugins."""
+    plugins_dir = _plugins_dir()
+    if not plugins_dir.is_dir():
+        return []
+
+    plugins: list[PluginInfo] = []
+    for plugin_dir in sorted(plugins_dir.iterdir()):
+        manifest = plugin_dir / "plugin.json"
+        if manifest.is_file():
+            try:
+                data = json.loads(manifest.read_text())
+                plugins.append(PluginInfo(
+                    name=data.get("name", plugin_dir.name),
+                    version=data.get("version", "0.0.0"),
+                    description=data.get("description", ""),
+                    path=plugin_dir,
+                    skills=data.get("skills", []),
+                    agents=data.get("agents", []),
+                ))
+            except (json.JSONDecodeError, KeyError) as e:
+                logger.warning("Invalid plugin at %s: %s", plugin_dir, e)
+
+    return plugins
+
+
+def install_plugin(source: str | Path) -> PluginInfo | None:
+    """Install a plugin from a local directory."""
+    source_path = Path(source)
+    if not source_path.is_dir():
+        logger.error("Plugin source must be a directory: %s", source)
+        return None
+
+    manifest = source_path / "plugin.json"
+    if not manifest.is_file():
+        logger.error("No plugin.json found in %s", source)
+        return None
+
+    data = json.loads(manifest.read_text())
+    name = data.get("name", source_path.name)
+
+    dest = _plugins_dir() / name
+    dest.mkdir(parents=True, exist_ok=True)
+
+    # Copy plugin files
+    shutil.copytree(source_path, dest, dirs_exist_ok=True)
+    logger.info("Installed plugin '%s' to %s", name, dest)
+
+    return PluginInfo(
+        name=name,
+        version=data.get("version", "0.0.0"),
+        description=data.get("description", ""),
+        path=dest,
+        skills=data.get("skills", []),
+        agents=data.get("agents", []),
+    )
+
+
+def uninstall_plugin(name: str) -> bool:
+    """Uninstall a plugin by name."""
+    dest = _plugins_dir() / name
+    if dest.is_dir():
+        shutil.rmtree(dest)
+        logger.info("Uninstalled plugin '%s'", name)
+        return True
+    return False
+
+
+def get_plugin_skill_dirs() -> list[Path]:
+    """Get skill directories from all installed plugins."""
+    dirs: list[Path] = []
+    for plugin in list_plugins():
+        skills_dir = plugin.path / "skills"
+        if skills_dir.is_dir():
+            dirs.append(skills_dir)
+    return dirs
+
+
+def get_plugin_agent_dirs() -> list[Path]:
+    """Get agent directories from all installed plugins."""
+    dirs: list[Path] = []
+    for plugin in list_plugins():
+        agents_dir = plugin.path / "agents"
+        if agents_dir.is_dir():
+            dirs.append(agents_dir)
+    return dirs

{drydock_cli-1.2.1 → drydock_cli-1.3.1}/drydock/core/prompts/cli.md

@@ -38,10 +38,17 @@ HOW to delegate:
 task(task="Explore the project structure and list all modules", agent="explore")
 task(task="Analyze why test_auth fails with KeyError", agent="diagnostic")
 task(task="Plan the refactoring of the auth module", agent="planner")
+task(task="Review the auth module for security issues", agent="explore", background=true)
 invoke_skill(skill_name="review")
 invoke_skill(skill_name="investigate", arguments="Fix the login timeout bug")
 ```
 
+Background subagents (background=true):
+- Run without blocking your main conversation
+- Results saved to task list — check with task_list
+- Use for parallel work: launch multiple subagents, then check results
+- Example: `task(task="Explore module A", agent="explore", background=true)` then `task(task="Explore module B", agent="explore", background=true)` — both run simultaneously
+
 WHEN to delegate (ALWAYS do this):
 - Project has 3+ files to examine → `task(..., agent="explore")` FIRST
 - Need to understand unfamiliar code → explore subagent, then you fix

drydock_cli-1.3.1/drydock/core/session/checkpoints.py

@@ -0,0 +1,123 @@
+"""Checkpoint system — snapshot files before edits for rewind.
+
+Tracks file state before each edit so users can rewind to any point.
+Stores snapshots in memory (session-scoped, not persisted).
+"""
+
+from __future__ import annotations
+
+import logging
+import shutil
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class FileSnapshot:
+    path: str
+    content: str  # Original content before edit
+    timestamp: str
+
+
+@dataclass
+class Checkpoint:
+    id: int
+    description: str
+    snapshots: list[FileSnapshot] = field(default_factory=list)
+    message_count: int = 0  # Number of messages at this point
+    timestamp: str = ""
+
+    def __post_init__(self):
+        if not self.timestamp:
+            self.timestamp = datetime.now().strftime("%H:%M:%S")
+
+
+class CheckpointManager:
+    """Manages file checkpoints for rewind capability."""
+
+    def __init__(self) -> None:
+        self._checkpoints: list[Checkpoint] = []
+        self._counter = 0
+
+    def create_checkpoint(self, description: str, message_count: int = 0) -> Checkpoint:
+        """Create a new checkpoint."""
+        self._counter += 1
+        cp = Checkpoint(
+            id=self._counter,
+            description=description,
+            message_count=message_count,
+        )
+        self._checkpoints.append(cp)
+        logger.debug("Checkpoint %d: %s", cp.id, description)
+        return cp
+
+    def snapshot_file(self, file_path: str) -> None:
+        """Save the current content of a file before editing it."""
+        if not self._checkpoints:
+            self.create_checkpoint("auto")
+
+        path = Path(file_path)
+        if not path.exists():
+            return
+
+        try:
+            content = path.read_text(encoding="utf-8", errors="replace")
+            snapshot = FileSnapshot(
+                path=str(path.resolve()),
+                content=content,
+                timestamp=datetime.now().strftime("%H:%M:%S"),
+            )
+            self._checkpoints[-1].snapshots.append(snapshot)
+        except (OSError, PermissionError) as e:
+            logger.warning("Cannot snapshot %s: %s", file_path, e)
+
+    def list_checkpoints(self) -> list[Checkpoint]:
+        """List all checkpoints."""
+        return list(self._checkpoints)
+
+    def rewind_to(self, checkpoint_id: int) -> list[str]:
+        """Restore files from a checkpoint. Returns list of restored file paths."""
+        target = None
+        for cp in self._checkpoints:
+            if cp.id == checkpoint_id:
+                target = cp
+                break
+
+        if not target:
+            return []
+
+        restored: list[str] = []
+
+        # Collect all snapshots from this checkpoint forward (to undo)
+        # We restore the EARLIEST snapshot of each file
+        file_originals: dict[str, str] = {}
+        for cp in self._checkpoints:
+            if cp.id >= checkpoint_id:
+                for snap in cp.snapshots:
+                    if snap.path not in file_originals:
+                        file_originals[snap.path] = snap.content
+
+        for path_str, content in file_originals.items():
+            try:
+                Path(path_str).write_text(content, encoding="utf-8")
+                restored.append(path_str)
+            except (OSError, PermissionError) as e:
+                logger.warning("Cannot restore %s: %s", path_str, e)
+
+        # Remove checkpoints from the target onward
+        self._checkpoints = [cp for cp in self._checkpoints if cp.id < checkpoint_id]
+
+        return restored
+
+    def rewind_last(self) -> list[str]:
+        """Rewind the most recent checkpoint."""
+        if not self._checkpoints:
+            return []
+        return self.rewind_to(self._checkpoints[-1].id)
+
+    @property
+    def count(self) -> int:
+        return len(self._checkpoints)

{drydock_cli-1.2.1 → drydock_cli-1.3.1}/drydock/core/system_prompt.py

@@ -291,4 +291,40 @@ def get_universal_system_prompt(
         if project_doc.strip():
             sections.append(project_doc)
 
+    # Load DRYDOCK.md per-project instructions (like CLAUDE.md)
+    drydock_md = _load_project_instructions()
+    if drydock_md:
+        sections.append(f"## Project Instructions\n\n{drydock_md}")
+
     return "\n\n".join(sections)
+
+
+def _load_project_instructions(max_bytes: int = 16_000) -> str:
+    """Load DRYDOCK.md and .drydock/rules/*.md for per-project instructions."""
+    parts: list[str] = []
+
+    # Check for DRYDOCK.md in project root
+    for name in ["DRYDOCK.md", "drydock.md", ".drydock/DRYDOCK.md"]:
+        path = Path.cwd() / name
+        try:
+            if path.is_file():
+                content = path.read_text("utf-8", errors="ignore")[:max_bytes]
+                parts.append(content)
+                break
+        except (OSError, PermissionError):
+            pass
+
+    # Load .drydock/rules/*.md for modular instructions
+    rules_dir = Path.cwd() / ".drydock" / "rules"
+    try:
+        if rules_dir.is_dir():
+            for rule_file in sorted(rules_dir.glob("*.md")):
+                try:
+                    content = rule_file.read_text("utf-8", errors="ignore")[:4000]
+                    parts.append(f"### {rule_file.stem}\n{content}")
+                except (OSError, PermissionError):
+                    pass
+    except (OSError, PermissionError):
+        pass
+
+    return "\n\n".join(parts)

{drydock_cli-1.2.1 → drydock_cli-1.3.1}/drydock/core/tools/builtins/read_file.py

@@ -72,6 +72,26 @@ class ReadFile(
     ) -> AsyncGenerator[ToolStreamEvent | ReadFileResult, None]:
         file_path = self._prepare_and_validate_path(args)
 
+        # Handle PDF files
+        if file_path.suffix.lower() == ".pdf":
+            content = self._read_pdf(file_path)
+            yield ReadFileResult(
+                path=str(file_path), content=content,
+                lines_read=content.count("\n"), was_truncated=False,
+            )
+            return
+
+        # Handle image files (describe what we can)
+        if file_path.suffix.lower() in (".png", ".jpg", ".jpeg", ".gif", ".bmp", ".svg"):
+            import os
+            size = os.path.getsize(file_path)
+            content = f"[Image file: {file_path.name}, {size} bytes, format: {file_path.suffix}]"
+            yield ReadFileResult(
+                path=str(file_path), content=content,
+                lines_read=1, was_truncated=False,
+            )
+            return
+
         read_result = await self._read_file(args, file_path)
 
         yield ReadFileResult(
@@ -81,6 +101,22 @@ class ReadFile(
             was_truncated=read_result.was_truncated,
         )
 
+    def _read_pdf(self, file_path: Path) -> str:
+        """Extract text from a PDF file."""
+        try:
+            import pypdf
+            reader = pypdf.PdfReader(str(file_path))
+            pages = []
+            for i, page in enumerate(reader.pages[:20]):  # Max 20 pages
+                text = page.extract_text()
+                if text:
+                    pages.append(f"--- Page {i+1} ---\n{text}")
+            return "\n\n".join(pages) if pages else "[PDF has no extractable text]"
+        except ImportError:
+            return "[PDF reading requires pypdf: pip install pypdf]"
+        except Exception as e:
+            return f"[Error reading PDF: {e}]"
+
     def resolve_permission(self, args: ReadFileArgs) -> ToolPermission | None:
         return resolve_file_tool_permission(
             args.path,

{drydock_cli-1.2.1 → drydock_cli-1.3.1}/drydock/core/tools/builtins/task.py

@@ -38,6 +38,10 @@ class TaskArgs(BaseModel):
         default="explore",
         description="Name of the agent profile to use (must be a subagent)",
     )
+    background: bool = Field(
+        default=False,
+        description="Run in background (non-blocking). Results available via task_list.",
+    )
 
 
 class TaskResult(BaseModel):
@@ -128,15 +132,56 @@ class Task(
             enabled=ctx.session_dir is not None,
         )
         base_config = VibeConfig.load(session_logging=session_logging)
+
+        # Apply per-agent model if configured
+        if agent_profile.model:
+            base_config = agent_profile.apply_to_config(base_config)
+
         subagent_loop = AgentLoop(
             config=base_config,
             agent_name=args.agent,
+            max_turns=agent_profile.max_turns,
             entrypoint_metadata=ctx.entrypoint_metadata,
         )
 
         if ctx and ctx.approval_callback:
             subagent_loop.set_approval_callback(ctx.approval_callback)
 
+        # Background execution: launch and return immediately
+        if args.background:
+            import asyncio
+            from drydock.core.tools.builtins.task_manager import _TASKS
+
+            task_id = f"bg-{args.agent}-{len(_TASKS)+1}"
+            _TASKS[task_id] = {
+                "id": task_id,
+                "title": f"[background] {args.task[:60]}",
+                "description": args.task,
+                "status": "in_progress",
+                "agent": args.agent,
+            }
+
+            async def _run_background():
+                response_parts = []
+                try:
+                    async for event in subagent_loop.act(args.task):
+                        if isinstance(event, AssistantEvent) and event.content:
+                            response_parts.append(event.content)
+                except Exception as e:
+                    response_parts.append(f"[Error: {e}]")
+                _TASKS[task_id]["status"] = "completed"
+                _TASKS[task_id]["result"] = "".join(response_parts)
+
+            asyncio.create_task(_run_background())
+
+            yield TaskResult(
+                response=f"Subagent '{args.agent}' launched in background (task {task_id}). Check status with task_list.",
+                turns_used=0,
+                completed=False,
+            )
+            return
+
+        # Foreground execution: block and collect results
         accumulated_response: list[str] = []
         completed = True
         try:

{drydock_cli-1.2.1 → drydock_cli-1.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "1.2.1"
+version = "1.3.1"
 description = "Drydock — nautical CLI coding agent"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -45,6 +45,7 @@ dependencies = [
     "pexpect>=4.9.0",
     "pydantic>=2.12.4",
     "pydantic-settings>=2.12.0",
+    "pypdf>=4.0.0",
     "pyperclip>=1.11.0",
     "python-dotenv>=1.0.0",
     "pyyaml>=6.0.0",