drydock-cli 2.7.48__tar.gz → 2.7.49__tar.gz

drydock_cli-2.7.49/.auto_release.lock

@@ -0,0 +1 @@
+3339404

{drydock_cli-2.7.48 → drydock_cli-2.7.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.7.48
+Version: 2.7.49
 Summary: Local-first CLI coding agent — tested with Gemma 4 26B via vLLM
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock
@@ -41,7 +41,6 @@ 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
 Requires-Dist: requests>=2.20.0
 Requires-Dist: rich>=14.0.0

{drydock_cli-2.7.48 → drydock_cli-2.7.49}/drydock/cli/textual_ui/app.py

@@ -326,7 +326,21 @@ class DrydockApp(App):  # noqa: PLR0904
             yield ContextProgress()
 
     async def on_mount(self) -> None:
-        self.theme = "textual-ansi"
+        # textual-ansi is the cleanest reading experience but isn't
+        # registered in every Textual version (e.g. some 8.2.x builds
+        # drop unused builtin themes). Falling back keeps the TUI from
+        # crashing on launch — the default theme renders correctly,
+        # just with sRGB colors instead of ANSI palette colors.
+        # Issue #18: Windows install crashed here on Textual 8.2.5
+        # with "Theme 'textual-ansi' has not been registered".
+        try:
+            self.theme = "textual-ansi"
+        except Exception as e:
+            logger.warning(
+                "preferred theme 'textual-ansi' not available "
+                "(textual=%s): %s — using default theme",
+                getattr(__import__("textual"), "__version__", "?"), e,
+            )
         self._terminal_notifier.restore()
 
         self._cached_messages_area = self.query_one("#messages")

{drydock_cli-2.7.48 → drydock_cli-2.7.49}/drydock/cli/textual_ui/widgets/messages.py

@@ -228,12 +228,39 @@ def _preserve_line_breaks(text: str) -> str:
     """
     if not text:
         return text
-    # Tabs at line start → 2 spaces. Done before anything else so the
-    # downstream regexes and Markdown widget see consistent indent.
-    text = "\n".join(
-        re.sub(r"^\t+", lambda m: "  " * len(m.group(0)), line)
-        for line in text.split("\n")
-    )
+    # Tab handling. Outside fenced code blocks, normalize tabs:
+    #   - Leading tabs → 2 spaces per tab (CommonMark sub-bullet indent).
+    #   - Mid-line tabs → expand to 4-col tab stops.
+    # Textual's Markdown widget routes raw tabs to Rich, which advances
+    # to the next 8-col stop. The "column" Rich sees depends on which
+    # markdown markers (* `_~) it has consumed, so tabs in mixed content
+    # land at unpredictable visible columns and produce the jumbled
+    # output users see (issue #16 follow-up reports). Inside fences,
+    # preserve tabs — the syntax highlighter handles them consistently.
+    _processed: list[str] = []
+    _in_fence = False
+    for _line in text.split("\n"):
+        if _line.lstrip().startswith("```"):
+            _in_fence = not _in_fence
+            _processed.append(_line)
+            continue
+        if _in_fence:
+            _processed.append(_line)
+            continue
+        # Leading tabs → 2 spaces.
+        _line = re.sub(
+            r"^\t+", lambda m: "  " * len(m.group(0)), _line
+        )
+        # Mid-line tabs (any remaining) → spaces at 4-col stops. The
+        # leading-indent transform already removed leading tabs, so any
+        # \t left is mid-line. Use a fixed 4-space replacement (good
+        # enough for table-like output the model emits; we don't try
+        # to replicate true tab-stop alignment because the surrounding
+        # content's visible width is unknowable without rendering).
+        if "\t" in _line:
+            _line = _line.replace("\t", "    ")
+        _processed.append(_line)
+    text = "\n".join(_processed)
     # First pass: rescue wall-of-text responses (flat prose, inline
     # enumerations, inline bold headings). See _break_walls_of_text.
     text = _break_walls_of_text(text)

{drydock_cli-2.7.48 → drydock_cli-2.7.49}/drydock/core/agent_loop.py

@@ -1027,8 +1027,23 @@ class AgentLoop:
                     prev_tool_name = assistant_msg.tool_calls[-1].function.name if assistant_msg.tool_calls[-1].function else None
             _readonly_tools = {"read_file", "grep", "glob", "ls", "pwd"}
             _prev_was_read = prev_tool_name in _readonly_tools
+            # Detect if prior write_file failed due to missing path argument.
+            _prev_tool_result = ""
+            if prev_role == Role.tool and self.messages:
+                _prev_tool_result = str(self.messages[-1].content or "")
+            _prev_write_path_error = (
+                prev_tool_name == "write_file"
+                and "empty path" in _prev_tool_result
+            )
             if _stall_attempt == 0:
-                if _prev_was_read:
+                if _prev_write_path_error:
+                    note = (
+                        "Your write_file call failed because the path argument was empty. "
+                        "Retry write_file RIGHT NOW with the correct path. "
+                        "Example: write_file(path='package/module.py', content='...'). "
+                        "Do NOT send an empty response — call write_file with a path."
+                    )
+                elif _prev_was_read:
                     note = (
                         f"You read a file but produced no output. "
                         f"Now use write_file, search_replace, or bash "

drydock_cli-2.7.49/drydock/core/config/_dotenv.py

@@ -0,0 +1,135 @@
+"""Minimal .env file reader/writer — replaces python-dotenv.
+
+Supports the subset drydock actually uses:
+  dotenv_values(path)           → dict[str, str | None]
+  set_key(path, key, value)     → None
+  unset_key(path, key)          → None
+
+Format handled:
+  KEY=VALUE          unquoted value
+  KEY="VALUE"        double-quoted value (backslash escapes respected)
+  KEY='VALUE'        single-quoted value (no escapes)
+  KEY=               empty string
+  # comment          ignored
+  (blank line)       preserved by set_key/unset_key
+"""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Union
+
+_LINE_RE = re.compile(
+    r"""
+    ^\s*
+    (?:export\s+)?          # optional 'export '
+    ([A-Za-z_][A-Za-z0-9_]*)  # key
+    \s*=\s*
+    (                       # value group
+        '(?:[^'\\]|\\.)*'   # single-quoted
+        |"(?:[^"\\]|\\.)*"  # double-quoted
+        |[^#\r\n]*          # unquoted (up to comment or EOL)
+    )?
+    (?:\s*\#.*)?            # optional trailing comment
+    $
+    """,
+    re.VERBOSE,
+)
+
+
+def _unescape_double(s: str) -> str:
+    return s.encode("raw_unicode_escape").decode("unicode_escape")
+
+
+def _parse_value(raw: str | None) -> str | None:
+    if raw is None:
+        return None
+    raw = raw.strip()
+    if not raw:
+        return ""
+    if raw.startswith('"') and raw.endswith('"') and len(raw) >= 2:
+        inner = raw[1:-1]
+        return _unescape_double(inner)
+    if raw.startswith("'") and raw.endswith("'") and len(raw) >= 2:
+        return raw[1:-1]
+    return raw
+
+
+def dotenv_values(path: Union[str, Path]) -> dict[str, str | None]:
+    """Read a .env file and return a dict of key→value pairs."""
+    path = Path(path)
+    result: dict[str, str | None] = {}
+    try:
+        text = path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return result
+    for line in text.splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+        m = _LINE_RE.match(line)
+        if m:
+            result[m.group(1)] = _parse_value(m.group(2))
+    return result
+
+
+def set_key(
+    path: Union[str, Path],
+    key: str,
+    value: str,
+    quote_mode: str = "auto",
+    export: bool = False,
+) -> None:
+    """Write or update KEY=VALUE in a .env file.
+
+    If the key already exists, its line is updated in place.
+    Otherwise the entry is appended.  The file is created if absent.
+    """
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Choose quoting: always double-quote so spaces and special chars are safe.
+    escaped = value.replace("\\", "\\\\").replace('"', '\\"')
+    new_line = f'{key}="{escaped}"'
+
+    if not path.exists():
+        path.write_text(new_line + "\n", encoding="utf-8")
+        return
+
+    lines = path.read_text(encoding="utf-8").splitlines(keepends=True)
+    key_re = re.compile(
+        r"^\s*(?:export\s+)?" + re.escape(key) + r"\s*="
+    )
+    replaced = False
+    out: list[str] = []
+    for line in lines:
+        if not replaced and key_re.match(line):
+            out.append(new_line + "\n")
+            replaced = True
+        else:
+            out.append(line)
+
+    if not replaced:
+        # Ensure file ends with a newline before appending.
+        if out and not out[-1].endswith("\n"):
+            out[-1] += "\n"
+        out.append(new_line + "\n")
+
+    path.write_text("".join(out), encoding="utf-8")
+
+
+def unset_key(
+    path: Union[str, Path],
+    key: str,
+) -> None:
+    """Remove KEY=... line from a .env file. No-op if file or key is absent."""
+    path = Path(path)
+    if not path.exists():
+        return
+
+    key_re = re.compile(
+        r"^\s*(?:export\s+)?" + re.escape(key) + r"\s*="
+    )
+    lines = path.read_text(encoding="utf-8").splitlines(keepends=True)
+    out = [line for line in lines if not key_re.match(line)]
+    path.write_text("".join(out), encoding="utf-8")

{drydock_cli-2.7.48 → drydock_cli-2.7.49}/drydock/core/config/_settings.py

@@ -9,7 +9,7 @@ import shlex
 import tomllib
 from typing import Annotated, Any, Literal
 
-from dotenv import dotenv_values
+from drydock.core.config._dotenv import dotenv_values
 from pydantic import BaseModel, Field, field_validator, model_validator
 from pydantic.fields import FieldInfo
 from pydantic_core import to_jsonable_python
@@ -656,7 +656,55 @@ class DrydockConfig(BaseSettings):
 
     @classmethod
     def _migrate(cls) -> None:
-        pass
+        """Backfill missing top-level keys in an existing user config.
+
+        `bootstrap_config_files` only writes the config when the file
+        does not exist, so users who installed an older version never
+        receive top-level keys added in subsequent releases (e.g.
+        `slim_system_prompt`, added in v2.7.x). The result: their
+        existing config is missing fields that downstream code expects,
+        and silent fallbacks mask the gap.
+
+        This pass: read the live config, compute the default, and
+        write back any TOP-LEVEL keys the user is missing — preserving
+        every value the user already has. Nested sections (providers,
+        models, tools) are NOT touched here; user customizations there
+        are intentional. Idempotent. addresses pattern config:upgrade_drift
+        """
+        if not get_harness_files_manager().persist_allowed:
+            return
+        try:
+            current = TomlFileSettingsSource(cls).toml_data
+        except Exception:
+            return  # config not on disk yet — bootstrap will create it
+        if not current:
+            return
+        try:
+            defaults = cls.create_default()
+        except Exception:
+            return
+        added: list[str] = []
+        for key, default_val in defaults.items():
+            if key in current:
+                continue
+            # Only fill in scalar / simple-collection top-level keys.
+            # Skip the heavyweight section keys that user installs
+            # configure deliberately (providers/models/tools/etc).
+            if isinstance(default_val, (dict, list)) and key in {
+                "providers", "models", "tools", "session_logging",
+                "project_context", "mcp_servers",
+                "tool_paths", "agent_paths", "skill_paths",
+                "enabled_tools", "disabled_tools",
+                "enabled_agents", "disabled_agents",
+                "enabled_skills", "disabled_skills",
+            }:
+                continue
+            current[key] = default_val
+            added.append(key)
+        if added:
+            cls.dump_config(
+                to_jsonable_python(current, exclude_none=True, fallback=str)
+            )
 
     @classmethod
     def load(cls, **overrides: Any) -> DrydockConfig:

{drydock_cli-2.7.48 → drydock_cli-2.7.49}/drydock/core/proxy_setup.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from dotenv import dotenv_values, set_key, unset_key
+from drydock.core.config._dotenv import dotenv_values, set_key, unset_key
 
 from drydock.core.paths import GLOBAL_ENV_FILE
 

{drydock_cli-2.7.48 → drydock_cli-2.7.49}/drydock/core/tools/builtins/write_file.py

@@ -710,7 +710,20 @@ class WriteFile(
 
     def _prepare_and_validate_path(self, args: WriteFileArgs) -> tuple[Path, bool, int]:
         if not args.path.strip():
-            raise ToolError("Path cannot be empty")
+            cwd = Path.cwd()
+            try:
+                pkg_dirs = [
+                    d.name for d in sorted(cwd.iterdir())
+                    if d.is_dir() and not d.name.startswith('.') and not d.name.startswith('_')
+                ][:4]
+                hint = f"Package dirs in {cwd.name}/: {', '.join(pkg_dirs)}" if pkg_dirs else f"cwd: {cwd}"
+            except OSError:
+                hint = f"cwd: {cwd}"
+            raise ToolError(
+                f"write_file requires a path argument — you sent an empty path. "
+                f"Retry as: write_file(path='<package>/<file>.py', content='...'). "
+                f"{hint}."
+            )
 
         # Warn about binary file extensions
         ext = Path(args.path).suffix.lower()

{drydock_cli-2.7.48 → drydock_cli-2.7.49}/drydock/setup/onboarding/screens/api_key.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import os
 from typing import ClassVar
 
-from dotenv import set_key
+from drydock.core.config._dotenv import set_key
 from textual.app import ComposeResult
 from textual.binding import Binding, BindingType
 from textual.containers import Center, Horizontal, Vertical

{drydock_cli-2.7.48 → drydock_cli-2.7.49}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "2.7.48"
+version = "2.7.49"
 description = "Local-first CLI coding agent — tested with Gemma 4 26B via vLLM"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -50,7 +50,6 @@ dependencies = [
     "pydantic-settings>=2.12.0",
     "pypdf>=4.0.0",
     "pyperclip>=1.11.0",
-    "python-dotenv>=1.0.0",
     "pyyaml>=6.0.0",
     "requests>=2.20.0",
     "rich>=14.0.0",

drydock_cli-2.7.49/tests/test_config_migration.py

@@ -0,0 +1,129 @@
+"""Regression tests for config upgrade migration (issue #17).
+
+Existing user configs created by older drydock versions don't get
+top-level keys added in subsequent releases — `bootstrap_config_files`
+only writes the file when it doesn't exist. `DrydockConfig._migrate()`
+backfills any missing top-level keys while preserving user values
+and never touching nested sections (providers/models/tools/etc).
+"""
+from __future__ import annotations
+
+import os
+import tempfile
+import tomllib
+from pathlib import Path
+
+import pytest
+import tomli_w
+
+
+def _setup_config(tmpdir: Path, contents: dict) -> Path:
+    drydock_dir = tmpdir / ".drydock"
+    drydock_dir.mkdir(parents=True, exist_ok=True)
+    cfg = drydock_dir / "config.toml"
+    with cfg.open("wb") as f:
+        tomli_w.dump(contents, f)
+    return cfg
+
+
+def _migrate_in_subprocess(drydock_home: Path) -> dict:
+    """Run the migration in a subprocess (clean env so module-level
+    DRYDOCK_HOME resolves to our temp dir) and return the resulting
+    config dict."""
+    import subprocess
+    py = "/home/bobef/miniforge3/envs/drydock/bin/python3"
+    code = (
+        "from drydock.core.config.harness_files._harness_manager "
+        "import init_harness_files_manager\n"
+        "init_harness_files_manager('user')\n"
+        "from drydock.core.config._settings import DrydockConfig\n"
+        "DrydockConfig._migrate()\n"
+    )
+    env = {**os.environ, "DRYDOCK_HOME": str(drydock_home)}
+    subprocess.run([py, "-c", code], env=env, check=True, capture_output=True)
+    cfg_file = drydock_home / "config.toml"
+    with cfg_file.open("rb") as f:
+        return tomllib.load(f)
+
+
+def test_migration_adds_missing_top_level_keys():
+    """An older config missing slim_system_prompt should get it back."""
+    with tempfile.TemporaryDirectory() as td:
+        tmp = Path(td)
+        _setup_config(tmp, {
+            "active_model": "local",
+            "auto_approve": False,
+            "system_prompt_id": "cli",
+            "providers": [{"name": "mistral", "api_base": "x",
+                           "api_key_env_var": "MISTRAL_API_KEY",
+                           "backend": "mistral"}],
+        })
+        cfg = _migrate_in_subprocess(tmp / ".drydock")
+        # Missing top-level keys should now be present.
+        assert "slim_system_prompt" in cfg
+        assert "auto_compact_threshold" in cfg
+        assert "context_warnings" in cfg
+        # User values preserved verbatim.
+        assert cfg["active_model"] == "local"
+        assert cfg["system_prompt_id"] == "cli"
+        # Nested sections not touched.
+        assert cfg["providers"] == [{"name": "mistral", "api_base": "x",
+                                     "api_key_env_var": "MISTRAL_API_KEY",
+                                     "backend": "mistral"}]
+
+
+def test_migration_idempotent():
+    """Running _migrate() twice should produce the same result."""
+    with tempfile.TemporaryDirectory() as td:
+        tmp = Path(td)
+        _setup_config(tmp, {
+            "active_model": "local",
+            "providers": [],
+        })
+        first = _migrate_in_subprocess(tmp / ".drydock")
+        second = _migrate_in_subprocess(tmp / ".drydock")
+        assert first == second
+
+
+def test_migration_skips_heavyweight_section_keys():
+    """User-customizable section keys (providers/models/tools) must
+    not be backfilled — leaving them missing means user explicitly
+    didn't want defaults there."""
+    with tempfile.TemporaryDirectory() as td:
+        tmp = Path(td)
+        _setup_config(tmp, {
+            "active_model": "local",
+            "providers": [{"name": "only", "api_base": "x",
+                           "api_key_env_var": "", "backend": "generic"}],
+        })
+        cfg = _migrate_in_subprocess(tmp / ".drydock")
+        # Only this user's one provider — no default mistral/llamacpp injected.
+        assert len(cfg["providers"]) == 1
+        # models / tools / session_logging not added.
+        assert "models" not in cfg
+        assert "tools" not in cfg
+        assert "session_logging" not in cfg
+
+
+def test_migration_no_op_when_no_config_file():
+    """Calling _migrate() when there's no existing config must be safe."""
+    with tempfile.TemporaryDirectory() as td:
+        tmp = Path(td)
+        (tmp / ".drydock").mkdir(parents=True, exist_ok=True)
+        # Don't create config.toml.
+        # Migrate should silently no-op and not raise.
+        import subprocess
+        py = "/home/bobef/miniforge3/envs/drydock/bin/python3"
+        code = (
+            "from drydock.core.config.harness_files._harness_manager "
+            "import init_harness_files_manager\n"
+            "init_harness_files_manager('user')\n"
+            "from drydock.core.config._settings import DrydockConfig\n"
+            "DrydockConfig._migrate()\n"
+        )
+        env = {**os.environ, "DRYDOCK_HOME": str(tmp / ".drydock")}
+        result = subprocess.run([py, "-c", code], env=env,
+                                capture_output=True, text=True)
+        assert result.returncode == 0, result.stderr
+        # Migrate should NOT have created the file.
+        assert not (tmp / ".drydock" / "config.toml").exists()

{drydock_cli-2.7.48 → drydock_cli-2.7.49}/tests/test_wall_of_text_rescue.py

@@ -65,6 +65,31 @@ class TestTabIndentedBlocks:
         out = _preserve_line_breaks(text)
         assert "here.\n\nSecond" in out
 
+    def test_midline_tabs_expand_to_4_spaces(self):
+        """Mid-line tabs in prose/tables would land at unpredictable
+        columns under Rich's tab-stop renderer; expanding to a fixed 4
+        spaces gives consistent alignment regardless of surrounding
+        markdown markers."""
+        text = "Results:\n\nname\tvalue\nfoo\t1\nbar\t2"
+        out = _preserve_line_breaks(text)
+        assert "name    value" in out
+        assert "foo    1" in out
+        assert "\t" not in out  # all tabs gone outside fences
+
+    def test_fenced_code_preserves_tabs(self):
+        """Tabs inside ``` fences must NOT be touched — syntax highlighter
+        handles them consistently and code semantics depend on them."""
+        text = "Sample:\n```python\ndef foo():\n\treturn 1\n```\nDone."
+        out = _preserve_line_breaks(text)
+        # The tab inside the fence is preserved.
+        assert "\treturn 1" in out
+
+    def test_inline_tabs_in_prose_normalized(self):
+        text = "Step 1:\trun. Step 2:\tcheck."
+        out = _preserve_line_breaks(text)
+        assert "Step 1:    run" in out
+        assert "\t" not in out
+
 
 class TestBreakWallsOfText:
     def test_short_input_unchanged(self):