drydock-cli 2.4.0__tar.gz → 2.4.2__tar.gz

{drydock_cli-2.4.0 → drydock_cli-2.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.4.0
+Version: 2.4.2
 Summary: Drydock — nautical CLI coding agent
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock

{drydock_cli-2.4.0 → drydock_cli-2.4.2}/drydock/cli/cli.py

@@ -158,7 +158,15 @@ def run_cli(args: argparse.Namespace) -> None:
 
         stdin_prompt = get_prompt_from_stdin()
         if args.prompt is not None:
-            config.disabled_tools = [*config.disabled_tools, "ask_user_question"]
+            # Disable tools that Gemma 4 can't handle
+            gemma_disabled = []
+            try:
+                active = config.get_active_model()
+                if "gemma" in active.name.lower():
+                    gemma_disabled = ["todo", "task_create", "task_update", "task", "invoke_skill", "tool_search"]
+            except Exception:
+                pass
+            config.disabled_tools = [*config.disabled_tools, "ask_user_question", *gemma_disabled]
             programmatic_prompt = args.prompt or stdin_prompt
             if not programmatic_prompt:
                 print(
@@ -189,6 +197,23 @@ def run_cli(args: argparse.Namespace) -> None:
                 print(f"Error: {e}", file=sys.stderr)
                 sys.exit(1)
         else:
+            # Disable problematic tools for models that can't handle complex schemas
+            try:
+                active = config.get_active_model()
+                if "gemma" in active.name.lower():
+                    config.disabled_tools = [
+                        *config.disabled_tools,
+                        "ask_user_question",  # Gemma sends empty {} args
+                        "todo",  # Gemma sends empty {} args
+                        "task_create",  # Gemma loops on task management instead of coding
+                        "task_update",  # Gemma sends invalid args, loops 64+ times
+                        "task",  # Subagent delegation — Gemma can't use it properly
+                        "invoke_skill",  # Gemma loads wrong skills, leaks templates
+                        "tool_search",  # Not useful for local models
+                    ]
+            except (ValueError, AttributeError):
+                pass
+
             agent_loop = AgentLoop(
                 config,
                 agent_name=initial_agent_name,

{drydock_cli-2.4.0 → drydock_cli-2.4.2}/drydock/cli/textual_ui/app.py

@@ -589,8 +589,35 @@ class VibeApp(App):  # noqa: PLR0904
             )
             return True
 
-        if len(parts) > 1:
-            skill_content = f"{user_input}\n\n{skill_content}"
+        # Strip frontmatter — don't send raw YAML to the model
+        if skill_content.startswith("---"):
+            fm_parts = skill_content.split("---", 2)
+            if len(fm_parts) >= 3:
+                skill_content = fm_parts[2].strip()
+
+        # Substitute arguments ($ARGUMENTS, $0, $1)
+        arguments = parts[1] if len(parts) > 1 else ""
+        if arguments:
+            skill_content = skill_content.replace("$ARGUMENTS", arguments)
+            for i, arg in enumerate(arguments.split()[:10]):
+                skill_content = skill_content.replace(f"$ARGUMENTS[{i}]", arg)
+                skill_content = skill_content.replace(f"${i}", arg)
+        else:
+            # Clean up unreplaced placeholders
+            skill_content = skill_content.replace("$ARGUMENTS", "")
+            import re
+            for i in range(10):
+                skill_content = skill_content.replace(f"$ARGUMENTS[{i}]", "")
+                skill_content = skill_content.replace(f"${i}", "")
+
+        # Wrap as instruction, not raw content
+        skill_content = (
+            f"[SKILL: /{skill_name}] Follow these instructions:\n\n"
+            f"{skill_content}"
+        )
+
+        if arguments:
+            skill_content = f"{arguments}\n\n{skill_content}"
 
         await self._handle_user_message(skill_content)
         return True
@@ -746,7 +773,15 @@ class VibeApp(App):  # noqa: PLR0904
         await loading_area.mount(loading)
 
         try:
-            rendered_prompt = render_path_prompt(prompt, base_dir=Path.cwd())
+            # Limit path embedding to 16KB for local models (default 256KB causes context bloat)
+            max_embed = 16 * 1024
+            try:
+                active_model = self.agent_loop.config.get_active_model()
+                if "gemma" in active_model.name.lower():
+                    max_embed = 8 * 1024  # Even less for Gemma 4
+            except Exception:
+                pass
+            rendered_prompt = render_path_prompt(prompt, base_dir=Path.cwd(), max_embed_bytes=max_embed)
             async for event in self.agent_loop.act(rendered_prompt):
                 if self.event_handler:
                     await self.event_handler.handle_event(

{drydock_cli-2.4.0 → drydock_cli-2.4.2}/drydock/core/agent_loop.py

@@ -1814,7 +1814,12 @@ class AgentLoop:
         """Lightweight auto-context: list project files and key docs.
 
         Kept minimal to avoid bloating context — just filenames, no content.
+        Skip if prompt already has embedded content (TUI path_prompt does this).
         """
+        # Skip if the prompt already contains embedded file content (from render_path_prompt)
+        if "[SKILL:" in user_msg or "```" in user_msg[:500]:
+            return
+
         parts = []
 
         try:

{drydock_cli-2.4.0 → drydock_cli-2.4.2}/pyproject.toml

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

drydock_cli-2.4.2/scripts/test_tui_path.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python3
+"""Test the TUI code path without an interactive terminal.
+
+This exercises the SAME code path as the TUI (streaming, render_path_prompt,
+skill handling, approval callbacks) but captures output as text.
+
+Usage:
+    python3 scripts/test_tui_path.py -p "Read PRD.md and build the package" --cwd /path/to/project
+    python3 scripts/test_tui_path.py -p "Fix the bug" --timeout 300
+"""
+import argparse
+import asyncio
+import os
+import sys
+import time
+from pathlib import Path
+
+# Use the installed drydock
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+os.environ.setdefault("MISTRAL_API_KEY", "dummy")
+
+from drydock import __version__
+from drydock.core.config.harness_files import init_harness_files_manager
+init_harness_files_manager()
+
+from drydock.cli.cli import get_initial_agent_name
+from drydock.core.agent_loop import AgentLoop
+from drydock.core.config import VibeConfig, SessionLoggingConfig
+from drydock.core.types import (
+    AssistantEvent, ToolCallEvent, ToolResultEvent, UserMessageEvent,
+)
+
+# Simulate what TUI does: render_path_prompt
+from drydock.core.autocompletion.path_prompt_adapter import render_path_prompt
+
+
+async def run_tui_path(prompt: str, timeout: int = 300, cwd: str = "."):
+    """Run the exact TUI code path but capture output."""
+    os.chdir(cwd)
+
+    config = VibeConfig.load(
+        session_logging=SessionLoggingConfig(enabled=False)
+    )
+    # Ensure we use the user's active model
+    print(f"   Config active_model: {config.active_model}")
+    print(f"   Models: {[m.alias or m.name for m in config.models]}")
+
+    # TUI mode: streaming enabled, same tool filtering
+    # This is what cli.py does for TUI mode
+    try:
+        active = config.get_active_model()
+        if "gemma" in active.name.lower():
+            config.disabled_tools = [
+                *config.disabled_tools,
+                "ask_user_question",
+                "todo",
+            ]
+    except (ValueError, AttributeError):
+        pass
+
+    agent_loop = AgentLoop(
+        config,
+        agent_name="auto-approve",
+        enable_streaming=True,  # TUI uses streaming
+    )
+
+    # TUI does render_path_prompt — this is a key difference from headless
+    max_embed = 8 * 1024  # Gemma 4 limit
+    rendered = render_path_prompt(prompt, base_dir=Path.cwd(), max_embed_bytes=max_embed)
+
+    print(f"⚓ DryDock v{__version__} TUI-path test")
+    print(f"   Model: {config.active_model}")
+    print(f"   CWD: {os.getcwd()}")
+    print(f"   Prompt: {prompt[:100]}...")
+    print(f"   Rendered prompt size: {len(rendered)} chars")
+    print(f"   Timeout: {timeout}s")
+    print(f"{'='*60}")
+
+    start = time.time()
+    tool_calls = 0
+    writes = {}  # Track writes per file
+    errors = 0
+
+    try:
+        async def _run_with_timeout():
+            async for event in agent_loop.act(rendered):
+                yield event
+
+        deadline = time.time() + timeout
+        async for event in agent_loop.act(rendered):
+            if time.time() > deadline:
+                print(f"\n  ⏰ TIMEOUT after {timeout}s")
+                break
+            elapsed = int(time.time() - start)
+
+            if isinstance(event, UserMessageEvent):
+                pass  # Skip user message echo
+
+            elif isinstance(event, AssistantEvent):
+                if event.content:
+                    # Print text output (truncated)
+                    text = event.content.strip()
+                    if text:
+                        for line in text.split('\n')[:5]:
+                            print(f"  💬 {line[:120]}")
+                        if text.count('\n') > 5:
+                            print(f"  💬 ... ({text.count(chr(10))} more lines)")
+
+            elif isinstance(event, ToolCallEvent):
+                tool_calls += 1
+                name = event.tool_name or "?"
+                args_preview = ""
+                if hasattr(event, 'args') and event.args:
+                    if hasattr(event.args, 'file_path'):
+                        args_preview = event.args.file_path
+                    elif hasattr(event.args, 'command'):
+                        args_preview = event.args.command[:60]
+                    elif hasattr(event.args, 'pattern'):
+                        args_preview = event.args.pattern
+                    elif hasattr(event.args, 'path'):
+                        args_preview = event.args.path
+
+                # Detect write loops
+                if name == "write_file" and args_preview:
+                    writes[args_preview] = writes.get(args_preview, 0) + 1
+                    if writes[args_preview] > 2:
+                        print(f"  ⚠️  LOOP DETECTED: {args_preview} written {writes[args_preview]} times!")
+
+                print(f"  [{elapsed:3d}s] 🔧 {name}: {args_preview}")
+
+            elif isinstance(event, ToolResultEvent):
+                success = True
+                msg = ""
+                if hasattr(event, 'error') and event.error:
+                    success = False
+                    errors += 1
+                    msg = str(event.error)[:100]
+                elif hasattr(event, 'result'):
+                    r = event.result
+                    if hasattr(r, 'message'):
+                        msg = r.message[:80] if r.message else ""
+                    elif isinstance(r, str):
+                        msg = r[:80]
+
+                mark = "✓" if success else "✗"
+                if msg:
+                    print(f"         {mark} {msg}")
+
+    except asyncio.TimeoutError:
+        print(f"\n  ⏰ TIMEOUT")
+    except Exception as e:
+        print(f"\n  ❌ ERROR: {e}")
+
+    elapsed = int(time.time() - start)
+    print(f"\n{'='*60}")
+    print(f"RESULTS:")
+    print(f"  Duration: {elapsed}s")
+    print(f"  Tool calls: {tool_calls}")
+    print(f"  Errors: {errors}")
+    print(f"  Files written: {dict(writes)}")
+
+    # Check if --help works
+    # Find package directories
+    for d in Path.cwd().iterdir():
+        if d.is_dir() and (d / "__init__.py").exists():
+            import subprocess
+            result = subprocess.run(
+                [sys.executable, "-m", d.name, "--help"],
+                capture_output=True, text=True, timeout=10,
+                cwd=str(Path.cwd()),
+            )
+            if result.returncode == 0:
+                print(f"  --help: ✓ PASS ({d.name})")
+            else:
+                print(f"  --help: ✗ FAIL ({d.name})")
+                print(f"    {result.stderr[:200]}")
+
+    # Detect issues
+    issues = []
+    for f, count in writes.items():
+        if count > 2:
+            issues.append(f"WRITE LOOP: {f} written {count} times")
+    if errors > 5:
+        issues.append(f"HIGH ERROR RATE: {errors} tool errors")
+    if elapsed >= timeout:
+        issues.append("TIMEOUT")
+
+    if issues:
+        print(f"\n⚠️  ISSUES DETECTED:")
+        for issue in issues:
+            print(f"  - {issue}")
+    else:
+        print(f"\n✅ No issues detected")
+
+    return len(issues) == 0
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Test DryDock TUI code path")
+    parser.add_argument("-p", "--prompt", required=True)
+    parser.add_argument("--cwd", default=".")
+    parser.add_argument("--timeout", type=int, default=300)
+    args = parser.parse_args()
+
+    success = asyncio.run(run_tui_path(args.prompt, args.timeout, args.cwd))
+    sys.exit(0 if success else 1)

drydock_cli-2.4.2/scripts/tui_test.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""Drive the REAL DryDock TUI with pexpect and capture everything.
+
+This runs the actual TUI binary, types into it, watches for output,
+and detects loops, errors, and completion.
+
+Usage:
+    python3 scripts/tui_test.py "Read PRD.md and build log_analyzer" --cwd /data3/test_drydock --timeout 300
+"""
+import pexpect
+import sys
+import time
+import re
+import os
+import argparse
+
+DRYDOCK_BIN = "/home/bobef/miniforge3/envs/drydock/bin/drydock"
+
+
+def run_tui_test(prompt: str, cwd: str = ".", timeout: int = 300):
+    os.chdir(cwd)
+
+    print(f"=== TUI TEST ===")
+    print(f"Prompt: {prompt[:100]}")
+    print(f"CWD: {os.path.abspath(cwd)}")
+    print(f"Timeout: {timeout}s")
+    print(f"Binary: {DRYDOCK_BIN}")
+    print()
+
+    # Spawn the real TUI
+    child = pexpect.spawn(
+        DRYDOCK_BIN,
+        encoding='utf-8',
+        timeout=timeout,
+        maxread=100000,
+        env={**os.environ, "TERM": "xterm-256color", "COLUMNS": "120", "LINES": "30"},
+        cwd=cwd,
+    )
+
+    # Log everything
+    log_file = open("/tmp/tui_test_raw.log", "w")
+    child.logfile_read = log_file
+
+    start = time.time()
+    overwrites = 0
+    api_errors = 0
+    tool_calls = 0
+    last_tool = ""
+    write_files = {}
+
+    try:
+        # Wait for TUI to initialize (look for the input prompt)
+        print("[*] Waiting for TUI to start...")
+        child.expect([r'>', r'┌', r'Drydock'], timeout=30)
+        time.sleep(2)  # Let it fully render
+
+        print(f"[*] TUI started ({int(time.time()-start)}s). Sending prompt...")
+
+        # Type the prompt character by character (Textual needs real key events)
+        for char in prompt:
+            child.send(char)
+            time.sleep(0.01)  # Small delay between chars
+        time.sleep(0.5)
+        # Press Enter to submit
+        child.send('\r')
+        time.sleep(2)
+
+        print(f"[*] Prompt sent. Watching for activity...")
+
+        # Watch output in a loop
+        last_activity = time.time()
+        consecutive_idle = 0
+
+        while time.time() - start < timeout:
+            try:
+                # Read whatever is available (non-blocking with short timeout)
+                chunk = child.read_nonblocking(size=4096, timeout=10)
+                if chunk:
+                    last_activity = time.time()
+                    consecutive_idle = 0
+
+                    # Strip ANSI codes for analysis
+                    clean = re.sub(r'\x1b\[[0-9;]*[a-zA-Z]', '', chunk)
+                    clean = re.sub(r'\x1b\[[0-9;]*[?][0-9]*[a-zA-Z]', '', clean)
+                    clean = clean.replace('\r', '')
+
+                    # Detect patterns
+                    if "Overwritten" in clean or "overwritten" in clean:
+                        overwrites += 1
+                        # Extract filename
+                        m = re.search(r'(?:Overwritten|overwritten)\s+(\S+)', clean)
+                        fname = m.group(1) if m else "?"
+                        write_files[fname] = write_files.get(fname, 0) + 1
+                        if write_files[fname] > 2:
+                            print(f"  ⚠️  WRITE LOOP: {fname} overwritten {write_files[fname]} times!")
+
+                    if "API error" in clean or "400 Bad Request" in clean:
+                        api_errors += 1
+                        print(f"  ❌ API ERROR #{api_errors}")
+
+                    if "consecutive API errors" in clean:
+                        print(f"  ❌ CONSECUTIVE API ERRORS detected")
+
+                    # Detect tool calls
+                    for tc_match in re.finditer(r'[✓✕■□]\s+(Ran |Read |Overwritten |Created |Wrote |Retrieved )', clean):
+                        tool_calls += 1
+
+                    # Detect completion
+                    if "Stopping:" in clean:
+                        print(f"  🛑 STOPPED: model hit error limit")
+                        break
+
+                    # Print interesting lines
+                    for line in clean.split('\n'):
+                        line = line.strip()
+                        if not line or len(line) < 3:
+                            continue
+                        if any(kw in line for kw in ['✓', '✕', '■', '□', 'API error', 'LOOP', 'Stopping', '--help']):
+                            elapsed = int(time.time() - start)
+                            print(f"  [{elapsed:3d}s] {line[:120]}")
+
+            except pexpect.TIMEOUT:
+                consecutive_idle += 1
+                elapsed = int(time.time() - start)
+                if consecutive_idle > 3:
+                    print(f"  [{elapsed}s] ... idle for {consecutive_idle * 10}s")
+                if consecutive_idle > 12:  # 2 min idle = stuck
+                    print(f"  ⚠️  STUCK: no output for 2 minutes")
+                    break
+                continue
+
+            except pexpect.EOF:
+                print(f"  TUI exited")
+                break
+
+    except pexpect.TIMEOUT:
+        print(f"  ⏰ OVERALL TIMEOUT after {timeout}s")
+    except Exception as e:
+        print(f"  ❌ ERROR: {e}")
+    finally:
+        elapsed = int(time.time() - start)
+        child.close(force=True)
+        log_file.close()
+
+    # Results
+    print(f"\n{'='*60}")
+    print(f"RESULTS:")
+    print(f"  Duration: {elapsed}s")
+    print(f"  Tool calls detected: {tool_calls}")
+    print(f"  Overwrites: {overwrites}")
+    print(f"  API errors: {api_errors}")
+    print(f"  Files written: {dict(write_files)}")
+
+    # Check if package was built
+    import subprocess
+    for d in os.listdir(cwd):
+        init = os.path.join(cwd, d, "__init__.py")
+        if os.path.isfile(init):
+            result = subprocess.run(
+                [sys.executable, "-m", d, "--help"],
+                capture_output=True, text=True, timeout=10, cwd=cwd,
+            )
+            if result.returncode == 0:
+                print(f"  --help: ✓ PASS ({d})")
+            else:
+                print(f"  --help: ✗ FAIL ({d}: {result.stderr[:100]})")
+
+    issues = []
+    for f, c in write_files.items():
+        if c > 2:
+            issues.append(f"WRITE LOOP: {f} x{c}")
+    if api_errors > 0:
+        issues.append(f"API ERRORS: {api_errors}")
+    if elapsed >= timeout:
+        issues.append("TIMEOUT")
+
+    if issues:
+        print(f"\n⚠️  ISSUES:")
+        for i in issues:
+            print(f"  - {i}")
+    else:
+        print(f"\n✅ No issues")
+
+    return len(issues) == 0
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("prompt", help="Prompt to send to DryDock TUI")
+    parser.add_argument("--cwd", default=".")
+    parser.add_argument("--timeout", type=int, default=300)
+    args = parser.parse_args()
+
+    ok = run_tui_test(args.prompt, args.cwd, args.timeout)
+    sys.exit(0 if ok else 1)