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

drydock_cli-2.7.34/.auto_release.lock

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.7.33
+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.33 → 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.33 → drydock_cli-2.7.34}/drydock/core/tools/builtins/bash.py

@@ -547,6 +547,15 @@ class Bash(
                     _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 "
@@ -558,6 +567,19 @@ class Bash(
                             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 "

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

@@ -565,6 +565,38 @@ class SearchReplace(
         # "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,
@@ -572,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

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())

drydock_cli-2.7.34/drydock/graphrag/code_indexer.py

@@ -0,0 +1,213 @@
+"""AST-based code symbol indexer — extracts class/function/method defs
+with parent-class info and qualified names.
+
+Scope choice: stdlib `ast` only. We don't try to evaluate annotations or
+follow imports across files at index time — that's a v1 problem. What we
+DO record is enough to mitigate pattern 4 from MODEL_SHORTCOMINGS:
+
+    Q: where is `is_json` defined?
+    A: werkzeug/wrappers/request.py:412 (method on Request class)
+
+    Q: what does flask.wrappers.Request inherit from?
+    A: ['werkzeug.wrappers.Request', 'JSONMixin']
+
+The indexer walks .py files, extracts defs with `Visit*` AST visitors,
+and yields `SymbolRecord` entries. Storage layer (`storage.py`) writes
+these to SQLite.
+"""
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Iterator
+
+
+# Files we never index (vendored, generated, junk).
+_SKIP_DIR_NAMES = frozenset({
+    "__pycache__", ".git", ".venv", "venv", "node_modules",
+    ".tox", "dist", "build", ".mypy_cache", ".pytest_cache",
+    "site-packages",  # avoid indexing installed packages
+    ".eggs", "egg-info",
+})
+
+_MAX_FILE_BYTES = 1_000_000   # skip giant generated files
+
+
+@dataclass
+class SymbolRecord:
+    """One indexed symbol — flat shape, ready to write to SQLite."""
+    name: str
+    qualname: str
+    kind: str            # "class" | "function" | "method"
+    file: str            # absolute path
+    line: int            # 1-based
+    end_line: int        # 1-based, inclusive
+    parents: list[str] = field(default_factory=list)
+    docstring: str = ""
+
+    @property
+    def citation_id(self) -> str:
+        return f"{self.file}:{self.line}"
+
+
+def index_path(root: str | Path) -> Iterator[SymbolRecord]:
+    """Walk `root` recursively, yield a SymbolRecord per def found.
+
+    `root` may be a single file or a directory. Symlinks and skip-dirs
+    are pruned. Parse errors on individual files are swallowed (we yield
+    nothing for that file and continue).
+    """
+    root = Path(root).resolve()
+    if root.is_file() and root.suffix == ".py":
+        yield from _index_file(root)
+        return
+    if not root.is_dir():
+        return
+
+    for path in _walk_python_files(root):
+        try:
+            yield from _index_file(path)
+        except (SyntaxError, ValueError, UnicodeDecodeError):
+            # Index what we can; skip what we can't parse.
+            continue
+
+
+def _walk_python_files(root: Path) -> Iterator[Path]:
+    stack: list[Path] = [root]
+    while stack:
+        current = stack.pop()
+        try:
+            entries = list(current.iterdir())
+        except (PermissionError, OSError):
+            continue
+        for entry in entries:
+            if entry.is_symlink():
+                continue
+            if entry.is_dir():
+                if entry.name in _SKIP_DIR_NAMES or entry.name.startswith("."):
+                    continue
+                stack.append(entry)
+            elif entry.suffix == ".py" and entry.is_file():
+                try:
+                    if entry.stat().st_size > _MAX_FILE_BYTES:
+                        continue
+                except OSError:
+                    continue
+                yield entry
+
+
+def _index_file(path: Path) -> Iterator[SymbolRecord]:
+    text = path.read_text(encoding="utf-8", errors="replace")
+    tree = ast.parse(text, filename=str(path))
+    module_qualname = _module_qualname_for(path)
+    # Build the file's import alias map so base classes can be resolved
+    # to their canonical qualname (`from werkzeug.wrappers import Request
+    # as WR` → `WR -> werkzeug.wrappers.Request`).
+    alias_map = _build_alias_map(tree)
+    yield from _walk_node(tree, path, module_qualname, [], alias_map)
+
+
+def _build_alias_map(tree: ast.AST) -> dict[str, str]:
+    """Walk top-level `Import` / `ImportFrom` nodes and build the
+    {local_name: canonical_qualname} map. Only top-level imports — we
+    don't trace conditional/function-local imports (rare and usually
+    not load-bearing for class hierarchies)."""
+    alias_map: dict[str, str] = {}
+    for node in ast.iter_child_nodes(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                local = alias.asname or alias.name.split(".")[0]
+                # `import a.b.c` → local "a" → canonical "a.b.c"? No —
+                # use the full dotted name as the canonical for `as`
+                # cases, otherwise the bare name.
+                canonical = alias.asname and alias.name or alias.name
+                alias_map[local] = canonical
+        elif isinstance(node, ast.ImportFrom):
+            module = node.module or ""
+            for alias in node.names:
+                local = alias.asname or alias.name
+                canonical = f"{module}.{alias.name}" if module else alias.name
+                alias_map[local] = canonical
+    return alias_map
+
+
+def _walk_node(
+    node: ast.AST,
+    file: Path,
+    module_qualname: str,
+    qual_stack: list[str],
+    alias_map: dict[str, str],
+) -> Iterator[SymbolRecord]:
+    """Recursive AST walk. `qual_stack` is the chain of enclosing class /
+    function names so we can build qualified names like
+    `Foo.bar.helper` for nested defs."""
+    for child in ast.iter_child_nodes(node):
+        if isinstance(child, ast.ClassDef):
+            inner_qual = qual_stack + [child.name]
+            raw_parents = [_unparse(b) for b in child.bases]
+            resolved = [alias_map.get(p, p) for p in raw_parents]
+            yield SymbolRecord(
+                name=child.name,
+                qualname=_join_qual(module_qualname, inner_qual),
+                kind="class",
+                file=str(file),
+                line=child.lineno,
+                end_line=getattr(child, "end_lineno", child.lineno),
+                parents=resolved,
+                docstring=ast.get_docstring(child) or "",
+            )
+            yield from _walk_node(child, file, module_qualname, inner_qual, alias_map)
+        elif isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            inner_qual = qual_stack + [child.name]
+            kind = "method" if (qual_stack and qual_stack[-1][0].isupper()) else "function"
+            yield SymbolRecord(
+                name=child.name,
+                qualname=_join_qual(module_qualname, inner_qual),
+                kind=kind,
+                file=str(file),
+                line=child.lineno,
+                end_line=getattr(child, "end_lineno", child.lineno),
+                parents=[],
+                docstring=ast.get_docstring(child) or "",
+            )
+            yield from _walk_node(child, file, module_qualname, inner_qual, alias_map)
+        else:
+            yield from _walk_node(child, file, module_qualname, qual_stack, alias_map)
+
+
+def _module_qualname_for(file: Path) -> str:
+    """Best-effort module qualname. Uses `__init__.py` walks to detect
+    packages; falls back to the bare stem if we can't tell."""
+    parts: list[str] = [file.stem if file.stem != "__init__" else ""]
+    parent = file.parent
+    while parent != parent.parent:
+        if (parent / "__init__.py").is_file():
+            parts.insert(0, parent.name)
+            parent = parent.parent
+        else:
+            break
+    return ".".join(p for p in parts if p)
+
+
+def _join_qual(module_qualname: str, parts: list[str]) -> str:
+    chain = ".".join(parts)
+    if module_qualname:
+        return f"{module_qualname}.{chain}" if chain else module_qualname
+    return chain
+
+
+def _unparse(node: ast.AST) -> str:
+    """Best-effort string rendering of an AST node (Python 3.9+ has
+    ast.unparse). Used for base-class names."""
+    try:
+        return ast.unparse(node)
+    except Exception:
+        if isinstance(node, ast.Name):
+            return node.id
+        if isinstance(node, ast.Attribute):
+            try:
+                return f"{_unparse(node.value)}.{node.attr}"
+            except Exception:
+                return node.attr
+        return "<unparseable>"