drydock-cli 2.7.32__tar.gz → 2.7.34__tar.gz

drydock_cli-2.7.34/.auto_release.lock

@@ -0,0 +1 @@
+2365970

{drydock_cli-2.7.32 → drydock_cli-2.7.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.7.32
+Version: 2.7.34
 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

{drydock_cli-2.7.32 → drydock_cli-2.7.34}/drydock/cli/cli.py

@@ -68,8 +68,28 @@ def bootstrap_config_files() -> None:
     if not config_file.exists():
         try:
             config_file.parent.mkdir(parents=True, exist_ok=True)
+            default = DrydockConfig.create_default()
+            # Auto-detect a running local LLM server (llama.cpp, Ollama,
+            # vLLM, LM Studio). If found, point the default config at it
+            # and set local as the active model — so a fresh install with
+            # a local server already running starts up without demanding
+            # a Mistral API key.
+            try:
+                from drydock.core.config.local_detect import (
+                    detect_local_llm,
+                    patch_config_for_local,
+                )
+                info = detect_local_llm()
+                if info is not None:
+                    patch_config_for_local(default, info)
+                    rprint(
+                        f"[green]Detected {info.label} at {info.api_base} — "
+                        f"using model '{info.model_name}'.[/]"
+                    )
+            except Exception as e:  # detection must never break first launch
+                logger.debug("local-LLM detection failed: %s", e)
             with config_file.open("wb") as f:
-                tomli_w.dump(DrydockConfig.create_default(), f)
+                tomli_w.dump(default, f)
         except Exception as e:
             rprint(f"[yellow]Could not create default config file: {e}[/]")
 

drydock_cli-2.7.34/drydock/core/config/local_detect.py

@@ -0,0 +1,120 @@
+"""Auto-detection of a running local LLM server on first launch.
+
+Drydock's product pitch is "works out of the box with vLLM/Ollama/LM Studio/
+llama.cpp — no API key required." That promise was broken for fresh installs:
+the default `active_model` was the Mistral cloud devstral-2, which fired a
+`MissingAPIKeyError` and dropped the user into the onboarding flow. Users who
+already had a local server running still had to walk through the onboarding
+screens.
+
+This module probes the four common local-LLM endpoints with a short
+HTTP timeout. If any responds with an OpenAI-compatible `/models` listing,
+we capture the api_base and the first model id, and the bootstrap path
+writes a config that points at it directly. Net effect: a user with a
+running local server gets a working drydock on first launch with zero
+prompts.
+
+The probe is kept dependency-free (stdlib `urllib`) so it cannot break
+on import in environments where `httpx`/`requests` aren't yet installed.
+"""
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+
+
+# (label, api_base) — order matters: try most-likely first.
+# We try llama-server first (per the upstream PRD draft's recommended
+# Q3_K_M setup), then Ollama (largest install base of the four), then
+# vLLM (drydock's own dev stack), then LM Studio.
+_CANDIDATE_ENDPOINTS: list[tuple[str, str]] = [
+    ("llama.cpp", "http://127.0.0.1:8080/v1"),
+    ("Ollama",    "http://127.0.0.1:11434/v1"),
+    ("vLLM",      "http://127.0.0.1:8000/v1"),
+    ("LM Studio", "http://127.0.0.1:1234/v1"),
+]
+
+_PER_REQUEST_TIMEOUT_S = 0.8
+
+
+@dataclass(frozen=True)
+class LocalServerInfo:
+    label: str          # "vLLM" / "Ollama" / etc — informational only
+    api_base: str       # full URL ending in /v1
+    model_name: str     # first model id reported by the server
+
+
+def detect_local_llm() -> LocalServerInfo | None:
+    """Probe the candidate endpoints; return the first one that answers.
+
+    A "good" response is HTTP 200 from `<api_base>/models` returning JSON
+    of the form `{"data": [{"id": "..."}, ...]}` (the OpenAI standard).
+    Servers that don't expose this (e.g. raw Ollama on port 11434/api/*)
+    are skipped — drydock needs the OpenAI-compatible surface anyway.
+
+    Total worst-case wall time: ~3.2 s when all four endpoints are
+    unreachable. In practice each socket connect to a closed port fails
+    in single-digit ms, so an "all-miss" probe is typically <50 ms.
+    """
+    for label, api_base in _CANDIDATE_ENDPOINTS:
+        info = _probe_one(label, api_base)
+        if info is not None:
+            return info
+    return None
+
+
+def _probe_one(label: str, api_base: str) -> LocalServerInfo | None:
+    url = f"{api_base.rstrip('/')}/models"
+    req = urllib.request.Request(url, method="GET")
+    try:
+        with urllib.request.urlopen(req, timeout=_PER_REQUEST_TIMEOUT_S) as resp:
+            if resp.status != 200:
+                return None
+            payload = json.loads(resp.read().decode("utf-8", errors="replace"))
+    except (urllib.error.URLError, OSError, ValueError, TimeoutError):
+        return None
+
+    models = payload.get("data") if isinstance(payload, dict) else None
+    if not isinstance(models, list) or not models:
+        return None
+
+    first = models[0]
+    if not isinstance(first, dict):
+        return None
+    model_name = first.get("id")
+    if not isinstance(model_name, str) or not model_name:
+        return None
+
+    return LocalServerInfo(label=label, api_base=api_base, model_name=model_name)
+
+
+def patch_config_for_local(
+    config: dict, info: LocalServerInfo
+) -> None:
+    """Mutate a default-config dict in place so the detected local server
+    is the active model.
+
+    Strategy: keep the existing `llamacpp` provider entry but point it at
+    the detected api_base, and update the `local` model's name to the
+    detected model id. Set `active_model = "local"`. This preserves the
+    rest of the user's config (other providers, models, settings) — we
+    only touch the entries that matter for the local path.
+    """
+    config["active_model"] = "local"
+
+    providers = config.get("providers")
+    if isinstance(providers, list):
+        for provider in providers:
+            if isinstance(provider, dict) and provider.get("name") == "llamacpp":
+                provider["api_base"] = info.api_base
+                # api_key_env_var stays empty — local server doesn't need one
+                break
+
+    models = config.get("models")
+    if isinstance(models, list):
+        for model in models:
+            if isinstance(model, dict) and model.get("alias") == "local":
+                model["name"] = info.model_name
+                break

{drydock_cli-2.7.32 → drydock_cli-2.7.34}/drydock/core/tools/builtins/bash.py

@@ -538,14 +538,57 @@ class Bash(
             if entry and entry["hash"] == out_hash:
                 entry["count"] += 1
                 if entry["count"] >= 3:
-                    notice = (
-                        f"[NOTICE: this is the #{entry['count']} identical "
-                        f"run of `{args.command[:80]}` with byte-identical "
-                        f"output and rc={returncode}. Re-running will not "
-                        f"change anything — you must EDIT SOURCE CODE to "
-                        f"change this output. Previous stdout first 300 "
-                        f"chars:\n{stdout[:300]}]"
-                    )
+                    cmd_preview = args.command[:80]
+                    # Detect file-write-via-heredoc pattern: cat << ... > file
+                    # The model writes a file, gets empty stdout (rc=0), then
+                    # re-runs the same write thinking it didn't work.  Generic
+                    # "EDIT SOURCE CODE" confuses it — give a targeted hint.
+                    import re as _re
+                    _is_heredoc_write = bool(_re.search(
+                        r"cat\s+<<\s*['\"]?EOF['\"]?\s+>", args.command
+                    ))
+                    # Detect echo -e / printf with \n or \t escape sequences.
+                    # These loops when the shell doesn't interpret the escapes
+                    # (e.g. dash ignores echo -e; backslash doubling in quoting
+                    # turns \t into literal \t instead of a tab).  The generic
+                    # "EDIT SOURCE CODE" hint is wrong here — the model needs
+                    # to use $'...' quoting or write_file instead.
+                    _is_echo_escape = bool(_re.search(
+                        r'(?:echo\s+.*-[eE]|printf)\b', args.command
+                    ) and _re.search(r'\\[nt]', args.command))
+                    if _is_heredoc_write:
+                        notice = (
+                            f"[NOTICE: this is the #{entry['count']}th identical "
+                            f"heredoc write of `{cmd_preview}`. "
+                            f"The file already has this exact content — re-running "
+                            f"the same cat command will not change it. "
+                            f"If the feature is still broken, READ the file you "
+                            f"wrote (use read_file), find the bug in the content, "
+                            f"then fix it with write_file or search_replace with "
+                            f"CORRECTED content. Do NOT re-run this cat command.]"
+                        )
+                    elif _is_echo_escape:
+                        notice = (
+                            f"[NOTICE: this is the #{entry['count']}th identical "
+                            f"run of `{cmd_preview}` — escape sequences (\\n, \\t) "
+                            f"in echo -e / printf are NOT being interpreted correctly. "
+                            f"This shell may be /bin/sh (dash) where echo -e is a "
+                            f"no-op, or backslash doubling in quoting is consuming "
+                            f"the escape. "
+                            f"Use ANSI $'...' quoting: printf $'name\\\\tage\\\\n' "
+                            f"OR use Python: python3 -c \"print('name\\\\tage')\" "
+                            f"OR use write_file to create the test file directly. "
+                            f"Do NOT re-run this command unchanged.]"
+                        )
+                    else:
+                        notice = (
+                            f"[NOTICE: this is the #{entry['count']} identical "
+                            f"run of `{cmd_preview}` with byte-identical "
+                            f"output and rc={returncode}. Re-running will not "
+                            f"change anything — you must EDIT SOURCE CODE to "
+                            f"change this output. Previous stdout first 300 "
+                            f"chars:\n{stdout[:300]}]"
+                        )
                     yield self._build_result(
                         command=args.command,
                         stdout=notice,

{drydock_cli-2.7.32 → drydock_cli-2.7.34}/drydock/core/tools/builtins/search_replace.py

@@ -473,6 +473,17 @@ class SearchReplace(
         # the result content and pivots to read_file.
         read_state = ctx.read_file_state if ctx else None
         path_key = str(file_path)
+        # When the model passed a directory and we inferred the actual file,
+        # we scanned the file content during inference — register it as "read"
+        # so the read-before-edit check below passes instead of blocking.
+        if read_state is not None:
+            _orig = Path(args.file_path.strip()).expanduser()
+            if not _orig.is_absolute():
+                _orig = Path.cwd() / _orig
+            _orig = _orig.resolve()
+            if _orig.is_dir() and file_path.is_file() and _orig != file_path:
+                import time as _time
+                read_state.setdefault(path_key, {"timestamp": int(_time.time() * 1e9)})
         if read_state is not None and file_path.exists():
             prior = read_state.get(path_key)
             if prior is None:
@@ -535,17 +546,57 @@ class SearchReplace(
                     "remaining code", "code continues", "etc.",
                 ]
             ):
-                raise ToolError(
-                    f"Your replacement contains a placeholder ('{replacement[:50]}') "
-                    f"that would delete existing code. Provide the COMPLETE replacement "
-                    f"code, not a summary. If the code is unchanged, don't edit it."
+                yield SearchReplaceResult(
+                    file=str(file_path),
+                    blocks_applied=0,
+                    lines_changed=0,
+                    warnings=[],
+                    content=(
+                        f"REFUSED: your REPLACE block contains a placeholder "
+                        f"('{replacement[:60]}') that would delete existing code. "
+                        f"Provide the COMPLETE replacement — every line that should "
+                        f"remain, plus your changes. Do NOT summarise unchanged code."
+                    ),
                 )
+                return
 
         # Detect no-op edits where SEARCH and REPLACE are byte-identical.
         # Short-circuit before _apply_blocks so we never reach the ambiguous
         # "edited successfully (+0 lines)" path for this structural no-op.
         noop_blocks = [b for b in search_replace_blocks if b.search == b.replace]
         if noop_blocks:
+            noop_state = self.state.__dict__.setdefault("_sr_noop_history", {})
+            noop_key = str(file_path)
+            noop_entry = noop_state.get(noop_key, {"count": 0})
+            noop_entry["count"] += 1
+            noop_state[noop_key] = noop_entry
+            noop_count = noop_entry["count"]
+            if noop_count >= 2:
+                try:
+                    body = original_content[:3000]
+                    tail = (
+                        f"\n...[truncated, {original_content.count(chr(10))} lines total]"
+                        if len(original_content) > 3000 else ""
+                    )
+                    extra = (
+                        f"\n\n[HARD-STOP: #{noop_count} consecutive SEARCH==REPLACE no-op "
+                        f"on {file_path.name}. Your SEARCH and REPLACE blocks are still "
+                        f"byte-identical — this call can never change anything. "
+                        f"DO NOT retry search_replace on this file again. "
+                        f"REQUIRED: call write_file with overwrite=True and the complete "
+                        f"corrected file content. Current file:\n"
+                        f"-----FILE START-----\n{body}{tail}\n-----FILE END-----]"
+                    )
+                except Exception:
+                    extra = (
+                        f"\n\n[HARD-STOP: #{noop_count} consecutive SEARCH==REPLACE no-op "
+                        f"on {file_path.name}. Stop retrying. Use write_file overwrite=True.]"
+                    )
+            else:
+                extra = (
+                    f" Re-read the file with read_file, identify what you actually need "
+                    f"to change, and send a corrected SEARCH/REPLACE block."
+                )
             yield SearchReplaceResult(
                 file=str(file_path),
                 blocks_applied=0,
@@ -553,9 +604,7 @@ class SearchReplace(
                 warnings=[],
                 content=(
                     f"{file_path.name}: ALREADY CORRECT — the SEARCH and REPLACE text "
-                    f"are byte-identical, so this block can never make any change. "
-                    f"Re-read the file with read_file, identify what you actually need "
-                    f"to change, and send a corrected SEARCH/REPLACE block."
+                    f"are byte-identical, so this block can never make any change.{extra}"
                 ),
             )
             return
@@ -817,7 +866,47 @@ class SearchReplace(
             raise ToolError(f"File does not exist: {file_path}")
 
         if not file_path.is_file():
-            raise ToolError(f"Path is not a file: {file_path}")
+            # Model passed a directory. Try to infer the correct file by
+            # scanning for a file in the directory that contains the search text.
+            # This avoids the retry loop where the model gets "is a directory"
+            # and keeps passing the same directory path. Only attempt when we have
+            # SEARCH content — otherwise fall through to the "Path is not a file" handler.
+            if file_path.is_dir() and content:
+                blocks_for_infer = self._parse_search_replace_blocks(content)
+                if blocks_for_infer:
+                    search_text = blocks_for_infer[0].search.strip()
+                    if search_text and len(search_text) >= 10:
+                        # Scan files in the directory first (most likely match),
+                        # then fall back to the entire project.
+                        candidates: list[Path] = []
+                        scan_dirs = [file_path] + [project_root]
+                        files_checked = 0
+                        for scan_dir in scan_dirs:
+                            for f in scan_dir.rglob("*.py"):
+                                if files_checked > 200:
+                                    break
+                                if "__pycache__" in str(f) or ".git" in str(f):
+                                    continue
+                                if f in candidates:
+                                    continue
+                                files_checked += 1
+                                try:
+                                    text = f.read_text(encoding="utf-8", errors="replace")
+                                    if len(text) > 100_000:
+                                        continue
+                                    if search_text in text:
+                                        candidates.append(f)
+                                except Exception:
+                                    continue
+                            if candidates:
+                                break
+                        if len(candidates) == 1:
+                            file_path = candidates[0]
+                        elif candidates:
+                            candidates.sort(key=lambda p: len(str(p)))
+                            file_path = candidates[0]
+            if not file_path.is_file():
+                raise ToolError(f"Path is not a file: {file_path}")
 
         search_replace_blocks = self._parse_search_replace_blocks(content)
         if not search_replace_blocks:

drydock_cli-2.7.34/drydock/graphrag/__init__.py

@@ -0,0 +1,46 @@
+"""GraphRAG — persistent context module for Drydock Sovereign v2.
+
+A first-class deployable module per the SOVEREIGN_PRD. Phase-2 deliverable.
+
+This first cut focuses on the two highest-volume failure shapes from
+TRIAGE_v1.md:
+
+1. **Code graph** — symbol → definition site lookup, including parent-class
+   chains across packages. Mitigates pattern 4 (inheritance blindness:
+   model reads `flask/wrappers.py` 13× looking for `is_json` when the
+   answer is in werkzeug's parent class).
+
+2. **Project memory** — chunked markdown / text retrieval with citations.
+   Mitigates pattern 10c (multi-module rewrites exceed working-memory
+   budget) by giving the model a way to recall PRD goals and per-module
+   contracts across sessions.
+
+Local-only by design: SQLite storage, stdlib + scikit-learn for TF-IDF
+(swap-in for embeddings is a v1 concern). No remote services.
+
+Public surface:
+    from drydock.graphrag import Index, retrieve_symbols, retrieve_text
+    from drydock.graphrag.retriever import Retriever, RetrievalResult
+
+CLI entry point:
+    python -m drydock.graphrag ingest <path>
+    python -m drydock.graphrag query <text>
+    python -m drydock.graphrag symbols <name>
+"""
+from __future__ import annotations
+
+from drydock.graphrag.retriever import (
+    RetrievalResult,
+    Retriever,
+    SymbolHit,
+    TextHit,
+)
+from drydock.graphrag.storage import Index
+
+__all__ = [
+    "Index",
+    "Retriever",
+    "RetrievalResult",
+    "SymbolHit",
+    "TextHit",
+]

drydock_cli-2.7.34/drydock/graphrag/__main__.py

@@ -0,0 +1,121 @@
+"""GraphRAG CLI — `python -m drydock.graphrag <subcommand>`.
+
+Subcommands:
+
+    ingest <path>            Walk the path, index .py + .md/.txt into the DB.
+    query <text>             Run a retrieval and print symbol+text hits.
+    symbol <name>            Look up a class/function by name or qualname.
+    chain <qualname>         Walk the inheritance chain for a class.
+    stats                    Show counts.
+
+Default DB path: $DRYDOCK_GRAPHRAG_DB or ~/.drydock/graphrag.sqlite
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+from drydock.graphrag.storage import Index
+
+
+def _default_db_path() -> str:
+    env = os.environ.get("DRYDOCK_GRAPHRAG_DB")
+    if env:
+        return env
+    return str(Path.home() / ".drydock" / "graphrag.sqlite")
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="drydock.graphrag",
+        description="GraphRAG: code-graph + text retrieval for Drydock.",
+    )
+    p.add_argument(
+        "--db",
+        default=_default_db_path(),
+        help="SQLite path (default: $DRYDOCK_GRAPHRAG_DB or ~/.drydock/graphrag.sqlite)",
+    )
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    sp_ingest = sub.add_parser("ingest", help="Index a directory or file")
+    sp_ingest.add_argument("path", help="Path to a project root or single file")
+
+    sp_query = sub.add_parser("query", help="Retrieve mixed symbol+text hits")
+    sp_query.add_argument("text", nargs="+", help="Query text")
+    sp_query.add_argument("--text-limit", type=int, default=5)
+    sp_query.add_argument("--symbol-limit", type=int, default=5)
+
+    sp_sym = sub.add_parser("symbol", help="Look up a symbol by name")
+    sp_sym.add_argument("name")
+    sp_sym.add_argument("--limit", type=int, default=10)
+
+    sp_chain = sub.add_parser(
+        "chain", help="Walk the inheritance chain for a class"
+    )
+    sp_chain.add_argument("qualname")
+
+    sub.add_parser("stats", help="Show DB counts")
+
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _build_parser().parse_args(argv)
+    idx = Index(args.db)
+
+    if args.cmd == "ingest":
+        counts = idx.ingest_path(args.path)
+        print(
+            f"Ingested {counts['files']} files: "
+            f"{counts['symbols']} symbols, {counts['chunks']} text chunks."
+        )
+        print(f"DB: {args.db}")
+        return 0
+
+    if args.cmd == "query":
+        query_text = " ".join(args.text)
+        result = idx.retrieve(
+            query_text,
+            symbol_limit=args.symbol_limit,
+            text_limit=args.text_limit,
+        )
+        print(result.format())
+        return 0 if not result.is_empty() else 1
+
+    if args.cmd == "symbol":
+        hits = idx.find_symbol(args.name)[: args.limit]
+        if not hits:
+            print(f"No symbol found for '{args.name}'.")
+            return 1
+        for h in hits:
+            print(h.format())
+        return 0
+
+    if args.cmd == "chain":
+        chain = idx.inheritance_chain(args.qualname)
+        if not chain:
+            print(f"No class found for '{args.qualname}'.")
+            return 1
+        for i, h in enumerate(chain):
+            indent = "  " * i
+            arrow = "" if i == 0 else "↳ "
+            print(f"{indent}{arrow}{h.format()}")
+        return 0
+
+    if args.cmd == "stats":
+        s = idx.stats()
+        print(
+            f"symbols: {s['symbols']}\n"
+            f"text chunks: {s['chunks']}\n"
+            f"unique terms: {s['unique_terms']}\n"
+            f"DB: {args.db}"
+        )
+        return 0
+
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())