drydock-cli 1.7.1__tar.gz → 1.7.3__tar.gz

{drydock_cli-1.7.1 → drydock_cli-1.7.3}/PKG-INFO

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

@@ -493,6 +493,7 @@ class AgentLoop:
                     user_prompt=build_prompt,
                     config=self.config,
                     base_dir=Path.cwd(),
+                    backend=self.backend,
                 )
                 # Yield the summary directly to the user — don't let the model
                 # respond, because it will ignore the instructions and rebuild files.

{drydock_cli-1.7.1 → drydock_cli-1.7.3}/drydock/core/build_orchestrator.py

@@ -23,6 +23,8 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from drydock.core.config import ProviderConfig, VibeConfig
+from drydock.core.llm.types import BackendLike
+from drydock.core.types import LLMMessage, MessageList, Role
 
 
 def _get_active_provider(config: VibeConfig) -> ProviderConfig | None:
@@ -142,98 +144,88 @@ def extract_plan(response_text: str) -> BuildPlan:
     )
 
 
-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 = _get_active_provider(config)
-    if not provider:
-        raise RuntimeError("No provider configured for active model")
-
-    messages = [
-        {"role": "system", "content": "You are a project planner. Output ONLY a JSON build plan."},
-        {"role": "user", "content": plan_prompt},
-    ]
+def make_plan_from_prd(user_prompt: str) -> BuildPlan:
+    """Extract a build plan from the PRD text. No LLM needed.
 
-    # 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))
-    logger.debug("Planner response: %s", full_response[:500])
+    Parses the PRD looking for package name, module names, and structure.
+    Falls back to a sensible default if parsing fails.
+    """
+    import re
+    text = user_prompt.lower()
+
+    # Try to extract package name from headings or structure sections
+    pkg_name = "project"
+    # Look for directory structure like /log_analyzer or /my_package
+    dir_match = re.search(r'/(\w+)\s*\n\s*[├└]', user_prompt)
+    if dir_match:
+        pkg_name = dir_match.group(1)
+    else:
+        # Look for package-like names in the text
+        for pattern in [
+            r'package[:\s]+[`"]?(\w+)[`"]?',
+            r'/(\w+)\s*\n\s*(?:├|└)',
+            r'`(\w+)/\w+\.py`',
+            r'(\w+)/\w+\.py',
+        ]:
+            m = re.search(pattern, user_prompt)
+            if m and m.group(1) not in ("python", "usr", "bin", "home", "data", "tmp"):
+                pkg_name = m.group(1)
+                break
+
+    # Look for .py files mentioned in the PRD
+    py_files = re.findall(r'(\w+)\.py', user_prompt)
+    py_files = [f for f in py_files if f not in ("__init__", "__main__", "test", "setup", "conftest")]
+    py_files = list(dict.fromkeys(py_files))  # deduplicate preserving order
+
+    if not py_files:
+        # Default module set based on keywords
+        py_files = []
+        if any(kw in text for kw in ("parse", "parser", "ingest")):
+            py_files.append("parser")
+        if any(kw in text for kw in ("pattern", "group", "detect")):
+            py_files.append("patterns")
+        if any(kw in text for kw in ("anomal", "spike", "unusual")):
+            py_files.append("anomaly")
+        if any(kw in text for kw in ("root cause", "suggest", "diagnos")):
+            py_files.append("root_cause")
+        if any(kw in text for kw in ("cli", "command", "argparse")):
+            py_files.append("cli")
+        if not py_files:
+            py_files = ["core", "cli"]
+        py_files.append("utils")
+
+    # Ensure cli is last (it imports from everything else)
+    if "cli" in py_files:
+        py_files.remove("cli")
+        py_files.append("cli")
+
+    # Build file specs — cli imports from all others, others are independent
+    files = []
+    non_cli = [f for f in py_files if f != "cli"]
+    for f in py_files:
+        imports = []
+        if f == "cli":
+            imports = [f"{pkg_name}.{m}" for m in non_cli]
+        # Extract purpose from PRD context around the module name
+        purpose = f"Implementation for {f} module"
+        for line in user_prompt.split("\n"):
+            if f in line.lower() and len(line) > 10:
+                purpose = line.strip()[:100]
+                break
+        files.append(FileSpec(f"{pkg_name}/{f}.py", purpose, imports))
+
+    # Extract description
+    desc = "Python project"
+    first_para = user_prompt.split("\n\n")[0] if "\n\n" in user_prompt else user_prompt[:100]
+    for line in first_para.split("\n"):
+        if len(line.strip()) > 20 and not line.startswith("#"):
+            desc = line.strip()[:100]
+            break
 
-    try:
-        return extract_plan(full_response)
-    except ValueError:
-        # Retry with simpler prompt
-        logger.warning("First planner attempt failed, retrying with simpler prompt...")
-        simple_messages = [
-            {"role": "system", "content": "Output ONLY valid JSON. No text before or after."},
-            {"role": "user", "content": (
-                "Create a JSON build plan for a Python package. "
-                "The package should be called 'log_analyzer' with these files:\n"
-                '{"package_name":"log_analyzer","description":"Log analyzer tool",'
-                '"entry_point":"cli","files":['
-                '{"path":"log_analyzer/parser.py","purpose":"Parse log lines into structured events","imports":[]},'
-                '{"path":"log_analyzer/patterns.py","purpose":"Group similar messages, detect frequency spikes","imports":["log_analyzer.parser"]},'
-                '{"path":"log_analyzer/anomaly.py","purpose":"Detect anomalies using heuristics","imports":["log_analyzer.parser"]},'
-                '{"path":"log_analyzer/root_cause.py","purpose":"Generate root cause suggestions","imports":["log_analyzer.parser","log_analyzer.patterns"]},'
-                '{"path":"log_analyzer/cli.py","purpose":"CLI with argparse: analyze command, --format, --level, --summary-only","imports":["log_analyzer.parser","log_analyzer.patterns","log_analyzer.anomaly","log_analyzer.root_cause"]},'
-                '{"path":"log_analyzer/utils.py","purpose":"Utility functions for formatting output","imports":[]}]}\n\n'
-                "Adapt this plan based on the project description below. "
-                "Output ONLY the JSON, no other text.\n\n"
-                f"{user_prompt[:3000]}"
-            )},
-        ]
-        async with httpx.AsyncClient(timeout=300) as client:
-            resp2 = await client.post(
-                f"{provider.api_base}/chat/completions",
-                json={"model": config.active_model, "messages": simple_messages,
-                      "max_tokens": 2048, "temperature": 0.1},
-            )
-            resp2.raise_for_status()
-            full_response2 = resp2.json()["choices"][0]["message"]["content"]
-            logger.info("Retry planner response: %d chars", len(full_response2))
+    entry = "cli" if "cli" in py_files else py_files[-1]
 
-        try:
-            return extract_plan(full_response2)
-        except ValueError:
-            # Last resort: use the hardcoded default plan
-            logger.warning("Planner retry failed, using default log_analyzer plan")
-            return BuildPlan(
-                package_name="log_analyzer",
-                description="Log analyzer tool",
-                entry_point="cli",
-                files=[
-                    FileSpec("log_analyzer/parser.py", "Parse log lines into structured events", []),
-                    FileSpec("log_analyzer/patterns.py", "Group similar messages, detect spikes", ["log_analyzer.parser"]),
-                    FileSpec("log_analyzer/anomaly.py", "Detect anomalies using heuristics", ["log_analyzer.parser"]),
-                    FileSpec("log_analyzer/root_cause.py", "Generate root cause suggestions", ["log_analyzer.parser"]),
-                    FileSpec("log_analyzer/cli.py", "CLI with argparse: analyze, --format, --level flags", ["log_analyzer.parser", "log_analyzer.patterns", "log_analyzer.anomaly", "log_analyzer.root_cause"]),
-                    FileSpec("log_analyzer/utils.py", "Utility functions for formatting", []),
-                ],
-            )
+    logger.info("Plan from PRD: package=%s, files=%d, entry=%s", pkg_name, len(files), entry)
+    return BuildPlan(package_name=pkg_name, description=desc, entry_point=entry, files=files)
 
 
 # ============================================================================
@@ -324,8 +316,9 @@ async def implement_file(
     plan: BuildPlan,
     config: VibeConfig,
     base_dir: Path,
+    backend: BackendLike | None = None,
 ) -> bool:
-    """Ask the LLM to generate code for one file via direct API call."""
+    """Ask the LLM to generate code for one file."""
     module_lines = []
     for f in plan.files:
         marker = " <-- THIS FILE" if f.path == file_spec.path else ""
@@ -358,42 +351,52 @@ async def implement_file(
         existing_apis=existing_apis,
     )
 
-    # Direct API call — no AgentLoop overhead
     try:
-        import httpx
-
-        # Find the provider config
-        provider = _get_active_provider(config)
-        if not provider:
-            return False
+        system_msg = (
+            "You are a code implementation agent. Write a CONCISE Python file. "
+            "Output ONLY Python code. No markdown fences. No explanation. "
+            "FIRST LINE MUST BE: from __future__ import annotations\n"
+            "Keep it under 150 lines. Use absolute imports (from pkg.module import X). "
+            "Do NOT use relative imports. Do NOT import classes just for type hints — "
+            "use string literals instead: def foo(x: 'ClassName'). "
+            "Import EXACT names from the EXISTING APIs listed."
+        )
 
-        messages = [
-            {"role": "system", "content": (
-                "You are a code implementation agent. Write a CONCISE Python file. "
-                "Output ONLY Python code. No markdown fences. No explanation. "
-                "FIRST LINE MUST BE: from __future__ import annotations\n"
-                "Keep it under 150 lines. Use absolute imports (from pkg.module import X). "
-                "Do NOT use relative imports. Do NOT import classes just for type hints — "
-                "use string literals instead: def foo(x: 'ClassName'). "
-                "Import EXACT names from the EXISTING APIs listed."
-            )},
-            {"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": 2048,
-                    "temperature": 0.2,
-                },
+        msgs = MessageList()
+        msgs.append(LLMMessage(role=Role.system, content=system_msg))
+        msgs.append(LLMMessage(role=Role.user, content=prompt))
+
+        if backend:
+            # Use the same backend as the main agent loop
+            active_model = config.get_active_model()
+            result = await backend.complete(
+                model=active_model,
+                messages=msgs,
+                temperature=0.2,
+                max_tokens=2048,
             )
-            resp.raise_for_status()
-            data = resp.json()
-
-        content = data["choices"][0]["message"]["content"]
+            content = result.message.content or ""
+        else:
+            # Fallback: direct httpx call
+            import httpx
+            provider = _get_active_provider(config)
+            if not provider:
+                return False
+            async with httpx.AsyncClient(timeout=300) as client:
+                resp = await client.post(
+                    f"{provider.api_base}/chat/completions",
+                    json={
+                        "model": config.active_model,
+                        "messages": [
+                            {"role": "system", "content": system_msg},
+                            {"role": "user", "content": prompt},
+                        ],
+                        "max_tokens": 2048,
+                        "temperature": 0.2,
+                    },
+                )
+                resp.raise_for_status()
+                content = resp.json()["choices"][0]["message"]["content"]
 
         # Strip markdown fences if present
         if "```python" in content:
@@ -442,6 +445,7 @@ async def run_build_pipeline(
     user_prompt: str,
     config: VibeConfig,
     base_dir: Path | None = None,
+    backend: BackendLike | None = None,
 ) -> str:
     """Run the full multi-phase build pipeline.
 
@@ -450,12 +454,9 @@ async def run_build_pipeline(
     if base_dir is None:
         base_dir = Path.cwd()
 
-    # Phase 1: Plan
+    # Phase 1: Plan (deterministic — no LLM needed)
     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
+    plan = make_plan_from_prd(user_prompt)
 
     logger.info("Plan: package=%s, files=%d, entry=%s",
                 plan.package_name, len(plan.files), plan.entry_point)
@@ -474,7 +475,7 @@ async def run_build_pipeline(
         success = False
         for attempt in range(2):
             try:
-                success = await implement_file(file_spec, plan, config, base_dir)
+                success = await implement_file(file_spec, plan, config, base_dir, backend)
                 if success:
                     _fix_imports(base_dir / file_spec.path, plan.package_name)
                     break

{drydock_cli-1.7.1 → drydock_cli-1.7.3}/pyproject.toml

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