drydock-cli 1.5.4__tar.gz → 1.6.0__tar.gz

{drydock_cli-1.5.4 → drydock_cli-1.6.0}/PKG-INFO

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

@@ -474,12 +474,29 @@ class AgentLoop:
 
         yield UserMessageEvent(content=user_msg, message_id=user_message.message_id)
 
-        # === AUTO-DELEGATION ===
-        # Inject context automatically so the model doesn't have to choose to delegate.
-        # This replaces relying on the model to call task()/invoke_skill().
-        auto_context = self._build_auto_context(user_msg)
-        if auto_context:
-            self._inject_system_note(auto_context)
+        # === BUILD ORCHESTRATION ===
+        # For complex build tasks (PRD + multiple files), run the multi-phase
+        # pipeline instead of letting the model do everything in one context.
+        if self._is_build_task(user_msg):
+            try:
+                from drydock.core.build_orchestrator import run_build_pipeline
+                summary = await run_build_pipeline(
+                    user_prompt=user_msg,
+                    config=self.config,
+                    base_dir=Path.cwd(),
+                )
+                self._inject_system_note(summary)
+                logger.info("Build orchestrator completed successfully")
+            except Exception as e:
+                logger.warning("Build orchestrator failed (%s), falling back to normal flow", e)
+                auto_context = self._build_auto_context(user_msg)
+                if auto_context:
+                    self._inject_system_note(auto_context)
+        else:
+            # Normal flow: inject context for non-build tasks
+            auto_context = self._build_auto_context(user_msg)
+            if auto_context:
+                self._inject_system_note(auto_context)
 
         try:
             should_break_loop = False
@@ -585,6 +602,10 @@ class AgentLoop:
                                     except (json.JSONDecodeError, AttributeError):
                                         edit_path = ""
 
+                                    # AUTO-FIX: Fix packaging issues the model gets wrong
+                                    if edit_path and edit_path.endswith(".py"):
+                                        self._auto_fix_package(edit_path)
+
                                     # Auto-run diagnostics on edited Python files
                                     if edit_path and edit_path.endswith(".py"):
                                         try:
@@ -1658,6 +1679,98 @@ class AgentLoop:
 
         return None
 
+    def _is_build_task(self, user_msg: str) -> bool:
+        """Detect if a user message is a complex build task that needs orchestration."""
+        msg_lower = user_msg.lower()
+        has_build_verb = any(kw in msg_lower for kw in (
+            "build", "create a", "implement", "get started",
+            "set up", "scaffold", "review the prd", "review prd",
+        ))
+        has_complexity = (
+            len(user_msg) > 200
+            or any(kw in msg_lower for kw in (
+                "prd", "multiple", "package", "modules", "cli",
+                "features", "commands", "architecture", "structure",
+            ))
+        )
+        # Check if a PRD.md exists in the working directory
+        has_prd = Path.cwd().joinpath("PRD.md").exists() or Path.cwd().joinpath("prd.md").exists()
+        return has_build_verb and (has_complexity or has_prd)
+
+    def _auto_fix_package(self, file_path: str) -> None:
+        """Silently fix common packaging mistakes after model writes a file.
+
+        The model (devstral-24B) consistently fails at:
+        1. Creating __main__.py for packages
+        2. Using relative imports instead of absolute
+        This runs after every write_file/search_replace and fixes both.
+        """
+        try:
+            fp = Path(file_path)
+            if not fp.exists() or not fp.is_file():
+                return
+
+            pkg_dir = fp.parent
+            init_file = pkg_dir / "__init__.py"
+
+            # Only fix files inside a package (has __init__.py)
+            if not init_file.exists():
+                return
+
+            pkg_name = pkg_dir.name
+
+            # 1. Create __main__.py if missing
+            main_file = pkg_dir / "__main__.py"
+            if not main_file.exists():
+                # Find the most likely entry point (cli.py, main.py, app.py)
+                entry = None
+                entry_func = "main"
+                for candidate in ["cli.py", "main.py", "app.py", "__init__.py"]:
+                    cand_path = pkg_dir / candidate
+                    if cand_path.exists() and candidate != "__init__.py":
+                        # Check if it has a main() function
+                        try:
+                            content = cand_path.read_text()
+                            if "def main(" in content:
+                                entry = candidate[:-3]  # strip .py
+                                break
+                        except Exception:
+                            pass
+                if entry:
+                    main_content = (
+                        f"from {pkg_name}.{entry} import {entry_func}\n\n"
+                        f"if __name__ == \"__main__\":\n"
+                        f"    {entry_func}()\n"
+                    )
+                    main_file.write_text(main_content)
+                    logger.info("Auto-created %s/__main__.py (entry: %s.%s)", pkg_name, entry, entry_func)
+
+            # 2. Fix relative imports → absolute imports
+            try:
+                content = fp.read_text()
+                if f"from .{'' if content else ''}" in content:
+                    import re
+                    # Replace from .module import X → from pkg.module import X
+                    fixed = re.sub(
+                        r"from \.([\w.]+) import",
+                        f"from {pkg_name}.\\1 import",
+                        content,
+                    )
+                    # Replace from . import X → from pkg import X
+                    fixed = re.sub(
+                        r"from \. import",
+                        f"from {pkg_name} import",
+                        fixed,
+                    )
+                    if fixed != content:
+                        fp.write_text(fixed)
+                        logger.info("Auto-fixed relative imports in %s", fp.name)
+            except Exception:
+                pass
+
+        except Exception as e:
+            logger.debug("Auto-fix package failed for %s: %s", file_path, e)
+
     def _build_auto_context(self, user_msg: str) -> str | None:
         """Build auto-delegation context based on the prompt and project state.
 
@@ -1727,17 +1840,24 @@ class AgentLoop:
         ))
         if is_build and is_complex:
             parts.append(
-                "PLANNING REQUIRED — This is a complex build task. Before writing code:\n"
-                "1. List ALL files you will create (with brief purpose)\n"
-                "2. Define the package structure\n"
-                "3. Use ABSOLUTE imports (from pkg.module import X), NOT relative imports\n"
-                "4. Create files in dependency order (utilities first, then modules that import them)\n"
-                "5. After creating all files, test with: python3 -m package_name\n"
-                "6. If tests fail, READ the error, then FIX with search_replace"
+                "MANDATORY BUILD RULES:\n"
+                "1. Plan first: list ALL files you will create\n"
+                "2. ALWAYS create __main__.py so 'python3 -m package_name' works:\n"
+                "   ```python\n"
+                "   from package_name.cli import main\n"
+                "   if __name__ == '__main__':\n"
+                "       main()\n"
+                "   ```\n"
+                "3. Use ABSOLUTE imports: 'from pkg.module import X', NOT 'from .module import X'\n"
+                "4. Create test/sample data files BEFORE testing (the tool needs input to work)\n"
+                "5. Test with: python3 -m package_name (NOT python3 package/file.py)\n"
+                "6. If a test fails, read the error, fix with search_replace, then retry\n"
+                "7. After 1-2 successful tests, STOP and tell the user it's done"
             )
         elif is_build:
             parts.append(
-                "REMINDER: Use write_file to create files. Use absolute imports. "
+                "BUILD RULES: Use write_file to create files. Use absolute imports. "
+                "Create __main__.py for packages. Create test data before testing. "
                 "Test with python3 -m package_name (not python3 package/file.py)."
             )
 

drydock_cli-1.6.0/drydock/core/build_orchestrator.py

@@ -0,0 +1,422 @@
+"""Multi-phase build orchestrator.
+
+Instead of running everything in one context window (where the model wastes
+turns on packaging/import errors), this splits project builds into phases:
+
+Phase 1: PLAN — planner subagent reads the PRD, outputs a JSON build plan
+Phase 2: SCAFFOLD — pure Python creates dirs, __init__.py, __main__.py
+Phase 3: IMPLEMENT — one subagent per file, each with clean context
+Phase 4: (back in main loop) — test and fix
+
+Each phase gets a separate context window, so the model only does what
+it's good at (writing logic) and the framework handles what it's bad at
+(packaging, imports, project structure).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from drydock.core.config import VibeConfig
+
+if TYPE_CHECKING:
+    from drydock.core.agents.manager import AgentManager
+    from drydock.core.types import EntrypointMetadata
+
+logger = logging.getLogger(__name__)
+
+
+# ============================================================================
+# Data structures
+# ============================================================================
+
+@dataclass
+class FileSpec:
+    path: str
+    purpose: str
+    imports: list[str] = field(default_factory=list)
+
+
+@dataclass
+class BuildPlan:
+    package_name: str
+    description: str
+    entry_point: str
+    files: list[FileSpec]
+
+
+# ============================================================================
+# Phase 1: PLAN
+# ============================================================================
+
+PLAN_PROMPT = """Analyze this project request and output a JSON build plan.
+
+PROJECT REQUEST:
+{user_prompt}
+
+Output a JSON block inside ```json fences with this EXACT structure:
+```json
+{{
+  "package_name": "my_package",
+  "description": "One-line description of the project",
+  "entry_point": "cli",
+  "files": [
+    {{"path": "my_package/utils.py", "purpose": "Utility functions for X and Y", "imports": []}},
+    {{"path": "my_package/core.py", "purpose": "Core logic that does Z", "imports": ["my_package.utils"]}},
+    {{"path": "my_package/cli.py", "purpose": "CLI entry point with main() function using argparse", "imports": ["my_package.core"]}}
+  ]
+}}
+```
+
+RULES:
+- package_name: valid Python identifier, lowercase, underscores OK
+- entry_point: the module with main() function (usually "cli")
+- files: list in DEPENDENCY ORDER (dependencies first, entry_point last)
+- Each purpose must be specific enough to implement the file from
+- Do NOT include __init__.py or __main__.py (created automatically)
+- The entry_point module MUST have a main() function
+"""
+
+
+def extract_plan(response_text: str) -> BuildPlan:
+    """Extract a BuildPlan from the planner's free-text response."""
+    # Try fenced JSON block first
+    match = re.search(r"```(?:json)?\s*\n(.*?)\n```", response_text, re.DOTALL)
+    if match:
+        raw = match.group(1)
+    else:
+        # Fallback: find first { ... } with "package_name"
+        match = re.search(r"\{[^{}]*\"package_name\".*\}", response_text, re.DOTALL)
+        if match:
+            raw = match.group(0)
+        else:
+            raise ValueError("No JSON build plan found in planner response")
+
+    data = json.loads(raw)
+
+    files = []
+    for f in data.get("files", []):
+        files.append(FileSpec(
+            path=f["path"],
+            purpose=f["purpose"],
+            imports=f.get("imports", []),
+        ))
+
+    return BuildPlan(
+        package_name=data["package_name"],
+        description=data.get("description", ""),
+        entry_point=data.get("entry_point", "cli"),
+        files=files,
+    )
+
+
+async def run_planner(
+    user_prompt: str,
+    config: VibeConfig,
+) -> BuildPlan:
+    """Phase 1: Direct API call to create a build plan. No AgentLoop needed."""
+    import httpx
+
+    plan_prompt = PLAN_PROMPT.format(user_prompt=user_prompt)
+
+    provider = config.providers[0] if config.providers else None
+    if not provider:
+        raise RuntimeError("No provider configured")
+
+    messages = [
+        {"role": "system", "content": "You are a project planner. Output ONLY a JSON build plan."},
+        {"role": "user", "content": plan_prompt},
+    ]
+
+    # Truncate very long prompts to avoid timeout
+    if len(plan_prompt) > 6000:
+        plan_prompt = plan_prompt[:6000] + "\n\n[TRUNCATED — focus on the core features listed above]"
+
+    messages[1]["content"] = plan_prompt
+
+    async with httpx.AsyncClient(timeout=300) as client:
+        resp = await client.post(
+            f"{provider.api_base}/chat/completions",
+            json={
+                "model": config.active_model,
+                "messages": messages,
+                "max_tokens": 2048,
+                "temperature": 0.2,
+            },
+        )
+        resp.raise_for_status()
+        data = resp.json()
+
+    full_response = data["choices"][0]["message"]["content"]
+    logger.info("Planner response length: %d chars", len(full_response))
+
+    return extract_plan(full_response)
+
+
+# ============================================================================
+# Phase 2: SCAFFOLD
+# ============================================================================
+
+def scaffold_package(plan: BuildPlan, base_dir: Path) -> list[Path]:
+    """Phase 2: Create package structure deterministically. No LLM needed."""
+    pkg_dir = base_dir / plan.package_name
+    pkg_dir.mkdir(parents=True, exist_ok=True)
+
+    created = []
+
+    # __init__.py
+    init_path = pkg_dir / "__init__.py"
+    init_path.write_text(f'"""{plan.description}"""\n')
+    created.append(init_path)
+
+    # __main__.py with correct absolute import
+    main_path = pkg_dir / "__main__.py"
+    main_path.write_text(
+        f"from {plan.package_name}.{plan.entry_point} import main\n\n"
+        f'if __name__ == "__main__":\n'
+        f"    main()\n"
+    )
+    created.append(main_path)
+
+    # Create stub files so imports resolve during implementation
+    for file_spec in plan.files:
+        fp = base_dir / file_spec.path
+        fp.parent.mkdir(parents=True, exist_ok=True)
+        fp.write_text(f'"""{file_spec.purpose}"""\n\n# TODO: implement\n')
+        created.append(fp)
+
+    return created
+
+
+# ============================================================================
+# Phase 3: IMPLEMENT (one subagent per file)
+# ============================================================================
+
+FILE_PROMPT = """Write the COMPLETE implementation for `{file_path}`.
+
+Package: {package_name}
+Purpose: {purpose}
+
+Other modules in this package:
+{module_listing}
+
+{import_note}
+
+RULES:
+- Use write_file to write the complete file
+- Use ABSOLUTE imports: `from {package_name}.module import X`
+- Do NOT use relative imports (from .module)
+- Write production-quality code with type hints and docstrings
+- If this is the CLI module, it MUST have a `def main():` function using argparse
+- After writing the file, STOP immediately
+"""
+
+
+async def implement_file(
+    file_spec: FileSpec,
+    plan: BuildPlan,
+    config: VibeConfig,
+    base_dir: Path,
+) -> bool:
+    """Ask the LLM to generate code for one file via direct API call.
+
+    Instead of spawning a full AgentLoop (which causes recursion issues),
+    we make a direct chat completion call and write the result to disk.
+    This is much lighter — no tools, no loop, no context management.
+    """
+    module_lines = []
+    for f in plan.files:
+        marker = " <-- THIS FILE" if f.path == file_spec.path else ""
+        module_lines.append(f"  {f.path}: {f.purpose}{marker}")
+    module_listing = "\n".join(module_lines)
+
+    import_note = ""
+    if file_spec.imports:
+        import_note = f"This file should import from: {', '.join(file_spec.imports)}"
+
+    prompt = FILE_PROMPT.format(
+        file_path=file_spec.path,
+        package_name=plan.package_name,
+        purpose=file_spec.purpose,
+        module_listing=module_listing,
+        import_note=import_note,
+    )
+
+    # Direct API call — no AgentLoop overhead
+    try:
+        import httpx
+
+        # Find the provider config
+        provider = config.providers[0] if config.providers else None
+        if not provider:
+            return False
+
+        messages = [
+            {"role": "system", "content": (
+                "You are a code implementation agent. Write the COMPLETE Python file. "
+                "Output ONLY the Python code, no markdown fences, no explanation. "
+                "Use absolute imports (from package.module import X, NOT from .module import X)."
+            )},
+            {"role": "user", "content": prompt},
+        ]
+
+        async with httpx.AsyncClient(timeout=300) as client:
+            resp = await client.post(
+                f"{provider.api_base}/chat/completions",
+                json={
+                    "model": config.active_model,
+                    "messages": messages,
+                    "max_tokens": 4096,
+                    "temperature": 0.3,
+                },
+            )
+            resp.raise_for_status()
+            data = resp.json()
+
+        content = data["choices"][0]["message"]["content"]
+
+        # Strip markdown fences if present
+        if "```python" in content:
+            content = content.split("```python", 1)[1]
+            if "```" in content:
+                content = content.split("```", 1)[0]
+        elif "```" in content:
+            parts = content.split("```")
+            if len(parts) >= 3:
+                content = parts[1]
+                if content.startswith("python\n"):
+                    content = content[7:]
+
+        content = content.strip() + "\n"
+
+        # Write the file
+        file_path = base_dir / file_spec.path
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+        file_path.write_text(content)
+
+        # Verify syntax
+        import ast
+        try:
+            ast.parse(content)
+        except SyntaxError as e:
+            logger.warning("Syntax error in generated %s: %s", file_spec.path, e)
+            return False
+
+        return True
+
+    except Exception as e:
+        logger.warning("Failed to implement %s: %s", file_spec.path, e)
+        return False
+
+
+# ============================================================================
+# Main orchestrator
+# ============================================================================
+
+async def run_build_pipeline(
+    user_prompt: str,
+    config: VibeConfig,
+    base_dir: Path | None = None,
+) -> str:
+    """Run the full multi-phase build pipeline.
+
+    Returns a summary string for the main agent to display.
+    """
+    if base_dir is None:
+        base_dir = Path.cwd()
+
+    # Phase 1: Plan
+    logger.info("BUILD PHASE 1: Planning...")
+    try:
+        plan = await run_planner(user_prompt, config)
+    except (ValueError, json.JSONDecodeError, KeyError) as e:
+        raise RuntimeError(f"Planning failed: {e}") from e
+
+    logger.info("Plan: package=%s, files=%d, entry=%s",
+                plan.package_name, len(plan.files), plan.entry_point)
+
+    # Phase 2: Scaffold
+    logger.info("BUILD PHASE 2: Scaffolding...")
+    created = scaffold_package(plan, base_dir)
+    logger.info("Scaffolded %d files", len(created))
+
+    # Phase 3: Implement each file
+    logger.info("BUILD PHASE 3: Implementing %d files...", len(plan.files))
+    results = []
+    for i, file_spec in enumerate(plan.files):
+        logger.info("  Implementing [%d/%d]: %s", i + 1, len(plan.files), file_spec.path)
+        # Try up to 2 times per file
+        success = False
+        for attempt in range(2):
+            try:
+                success = await implement_file(file_spec, plan, config, base_dir)
+                if success:
+                    _fix_imports(base_dir / file_spec.path, plan.package_name)
+                    break
+                else:
+                    logger.warning("  Attempt %d failed for %s, retrying...", attempt + 1, file_spec.path)
+            except Exception as e:
+                logger.warning("  Attempt %d error for %s: %s", attempt + 1, file_spec.path, e)
+        results.append((file_spec.path, success))
+
+    # Build summary
+    succeeded = sum(1 for _, ok in results if ok)
+    failed_files = [path for path, ok in results if not ok]
+
+    summary_lines = [
+        f"PROJECT BUILT: {plan.package_name}",
+        f"Description: {plan.description}",
+        f"Files: {succeeded}/{len(plan.files)} implemented",
+        f"",
+        f"Package structure:",
+    ]
+    for f in plan.files:
+        status = "OK" if any(p == f.path and ok for p, ok in results) else "STUB"
+        summary_lines.append(f"  {f.path} [{status}] — {f.purpose}")
+
+    summary_lines.extend([
+        f"",
+        f"Entry point: python3 -m {plan.package_name}",
+        f"",
+        f"Test the project now by running: python3 -m {plan.package_name} --help",
+        f"If it fails, read the error and fix with search_replace.",
+    ])
+
+    if failed_files:
+        summary_lines.extend([
+            f"",
+            f"NEEDS IMPLEMENTATION: {', '.join(failed_files)}",
+            f"These files have stubs only. Implement them with write_file.",
+        ])
+
+    return "\n".join(summary_lines)
+
+
+def _fix_imports(file_path: Path, package_name: str) -> None:
+    """Fix relative imports in a file to absolute imports."""
+    try:
+        if not file_path.exists():
+            return
+        content = file_path.read_text()
+        if "from ." not in content:
+            return
+        fixed = re.sub(
+            r"from \.([\w.]+) import",
+            f"from {package_name}.\\1 import",
+            content,
+        )
+        fixed = re.sub(
+            r"from \. import",
+            f"from {package_name} import",
+            fixed,
+        )
+        if fixed != content:
+            file_path.write_text(fixed)
+            logger.info("Fixed relative imports in %s", file_path.name)
+    except Exception:
+        pass

{drydock_cli-1.5.4 → drydock_cli-1.6.0}/drydock/core/prompts/__init__.py

@@ -21,6 +21,7 @@ class SystemPrompt(Prompt):
     CLI = auto()
     EXPLORE = auto()
     TESTS = auto()
+    BUILDER = auto()
 
 
 class UtilityPrompt(Prompt):

drydock_cli-1.6.0/drydock/core/prompts/builder.md

@@ -0,0 +1,16 @@
+You are a code implementation agent. You write ONE file for a Python package.
+
+You will be given:
+- The file path to create
+- The file's purpose
+- The package structure (what other modules exist)
+- Which modules this file imports from
+
+Rules:
+- Write the COMPLETE file using write_file. Include all imports, classes, functions.
+- Use ABSOLUTE imports: `from package_name.module import X`, NOT `from .module import X`
+- Do NOT create __init__.py or __main__.py (already done)
+- Do NOT run bash commands or tests
+- Do NOT read other files unless absolutely necessary
+- After writing the file, STOP. Do not do anything else.
+- Write production-quality code: type hints, docstrings, error handling.

{drydock_cli-1.5.4 → drydock_cli-1.6.0}/drydock/core/prompts/cli.md

@@ -223,12 +223,18 @@ Error Handling:
 - After ANY error, your next action must be DIFFERENT from what just failed.
 - Never run the same failing command twice — the result won't change.
 
-Python Package Rules:
+Python Package Rules (MANDATORY):
 When creating Python packages (directories with __init__.py):
-- Use ABSOLUTE imports, not relative. Write `from mypackage.module import X`, NOT `from .module import X`
-- To run a package: `python3 -m mypackage` (requires __main__.py), NOT `python3 mypackage/main.py`
-- Relative imports (from .foo) ONLY work with `python3 -m`, not direct file execution
-- If you get "attempted relative import with no known parent package", switch to absolute imports
+- ALWAYS create __main__.py so `python3 -m mypackage` works. Contents:
+  ```
+  from mypackage.cli import main
+  if __name__ == "__main__":
+      main()
+  ```
+- Use ABSOLUTE imports: `from mypackage.module import X`, NOT `from .module import X`
+- NEVER run `python3 mypackage/file.py` — ALWAYS use `python3 -m mypackage`
+- Create sample/test data BEFORE running tests (e.g., create test.log before analyzing it)
+- After 1-2 successful test runs, STOP testing and summarize what you built
 
 Debugging Best Practices:
 When fixing bugs, follow this cycle: RUN → READ → FIX → VERIFY.

{drydock_cli-1.5.4 → drydock_cli-1.6.0}/pyproject.toml

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