drydock-cli 2.10.5__tar.gz → 2.10.7__tar.gz

{drydock_cli-2.10.5 → drydock_cli-2.10.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.10.5
+Version: 2.10.7
 Summary: Local-first CLI coding agent — tested with Gemma 4 26B via llama.cpp
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock

{drydock_cli-2.10.5 → drydock_cli-2.10.7}/drydock/cli/entrypoint.py

@@ -190,6 +190,140 @@ def check_and_resolve_trusted_folder() -> None:
         trusted_folders_manager.add_untrusted(cwd)
 
 
+def _warn_on_path_shadow() -> None:
+    """If a different drydock install — either on PATH or in a
+    well-known install dir — is newer than the one we're running,
+    print a one-line warning.
+
+    Operator observed 2026-06-08: ~/.local/bin/drydock was 2.9.46
+    (months old) while the auto-released install in
+    ~/miniforge3/envs/drydock/bin was 2.10.4. The fresh install
+    wasn't even on PATH (the conda env wasn't activated), so a
+    strict $PATH walk wouldn't catch this. We also scan a few
+    conventional install locations.
+
+    Opt-out: DRYDOCK_NO_SHADOW_WARN=1.
+    """
+    if os.environ.get("DRYDOCK_NO_SHADOW_WARN", "").strip().lower() in (
+        "1", "true", "yes",
+    ):
+        return
+    if __version__ == "dev":
+        # Running from source — every install would be "newer" by version
+        # number but the dev tree IS what's intended. Skip.
+        return
+    try:
+        import glob
+        import shutil
+        from packaging.version import Version
+        running_bin = shutil.which("drydock")
+        if not running_bin:
+            return
+        running_real = os.path.realpath(running_bin)
+
+        # 1) Anything on $PATH named drydock.
+        candidates: list[str] = []
+        for path_dir in os.environ.get("PATH", "").split(os.pathsep):
+            if path_dir and os.path.isdir(path_dir):
+                p = os.path.join(path_dir, "drydock")
+                if os.path.isfile(p) and os.access(p, os.X_OK):
+                    candidates.append(p)
+        # 2) Conventional install dirs (uv tool, conda envs) — these
+        # often contain drydock but aren't on PATH unless activated.
+        home = os.path.expanduser("~")
+        for pattern in (
+            os.path.join(home, ".local", "bin", "drydock"),
+            os.path.join(home, "miniforge3", "envs", "*", "bin", "drydock"),
+            os.path.join(home, "miniconda3", "envs", "*", "bin", "drydock"),
+            os.path.join(home, "anaconda3", "envs", "*", "bin", "drydock"),
+            os.path.join(home, ".local", "share", "uv", "tools",
+                         "drydock-cli", "bin", "drydock"),
+            "/usr/local/bin/drydock",
+        ):
+            for p in glob.glob(pattern):
+                if os.path.isfile(p) and os.access(p, os.X_OK):
+                    candidates.append(p)
+
+        seen: set[str] = {running_real}
+        for cand in candidates:
+            cand_real = os.path.realpath(cand)
+            if cand_real in seen:
+                continue
+            seen.add(cand_real)
+            try:
+                other_ver = _read_drydock_version_for(cand_real)
+            except Exception:
+                continue
+            if not other_ver:
+                continue
+            if Version(other_ver) > Version(__version__):
+                rprint(
+                    f"[yellow]Note: drydock {other_ver} is installed at "
+                    f"{cand}, but this session is running {__version__} "
+                    f"from {running_real}. To use the newer one, run "
+                    f"{cand} directly or put its bin dir first on PATH. "
+                    f"Silence: DRYDOCK_NO_SHADOW_WARN=1.[/]"
+                )
+                return  # one warning is enough
+    except Exception:
+        # Never block startup on a diagnostic.
+        return
+
+
+def _read_drydock_version_for(executable_path: str) -> str | None:
+    """Given a drydock executable path, return the installed version
+    by reading dist-info metadata. Tries two env layouts: the binary's
+    sibling (env/bin/drydock + env/lib/.../site-packages — conda/venv
+    style) and the binary's shebang-pointed python (uv tool installs
+    that put the script in ~/.local/bin but the env at
+    ~/.local/share/uv/tools/...). No subprocess fork."""
+    candidate_envs: list[str] = []
+    # Layout A: <env>/bin/drydock — env root is one level up.
+    bin_dir = os.path.dirname(executable_path)
+    candidate_envs.append(os.path.dirname(bin_dir))
+    # Layout B: read the shebang from the executable and resolve the
+    # python interpreter path to its env root.
+    try:
+        with open(executable_path, "rb") as f:
+            first = f.readline()
+        if first.startswith(b"#!"):
+            shebang = first[2:].strip().decode("utf-8", errors="replace")
+            # shebang format is usually "/path/to/env/bin/python" possibly
+            # followed by args; take the executable token.
+            py = shebang.split()[0] if shebang.split() else ""
+            if py:
+                # Use the literal shebang path, NOT realpath — many tool
+                # installers (uv) ship a venv where bin/python is a
+                # symlink to system python. realpath would jump us out
+                # of the venv to /usr, losing the dist-info location.
+                py_bin_dir = os.path.dirname(py)
+                candidate_envs.append(os.path.dirname(py_bin_dir))
+    except OSError:
+        pass
+
+    for env_root in candidate_envs:
+        lib_dir = os.path.join(env_root, "lib")
+        if not os.path.isdir(lib_dir):
+            continue
+        for py_dir in sorted(os.listdir(lib_dir), reverse=True):
+            candidate_sp = os.path.join(lib_dir, py_dir, "site-packages")
+            if not os.path.isdir(candidate_sp):
+                continue
+            try:
+                for entry in os.listdir(candidate_sp):
+                    if entry.startswith("drydock_cli-") and entry.endswith(".dist-info"):
+                        meta = os.path.join(candidate_sp, entry, "METADATA")
+                        if not os.path.isfile(meta):
+                            continue
+                        with open(meta, encoding="utf-8") as f:
+                            for line in f:
+                                if line.startswith("Version:"):
+                                    return line.split(":", 1)[1].strip()
+            except OSError:
+                continue
+    return None
+
+
 def main() -> None:
     args = parse_arguments()
 
@@ -202,6 +336,9 @@ def main() -> None:
         init_harness_files_manager("user", "project")
         sys.exit(run_doctor(apply=bool(getattr(args, "fix", False))))
 
+    # PATH-shadow check (after early-exit args, before interactive setup).
+    _warn_on_path_shadow()
+
     if args.workdir:
         workdir = args.workdir.expanduser().resolve()
         if not workdir.is_dir():

{drydock_cli-2.10.5 → drydock_cli-2.10.7}/drydock/core/llm/format.py

@@ -182,16 +182,31 @@ class APIToolFormatHandler:
         return "api"
 
     def get_available_tools(self, tool_manager: ToolManager) -> list[AvailableTool]:
-        return [
-            AvailableTool(
-                function=AvailableFunction(
-                    name=tool_class.get_name(),
-                    description=tool_class.description,
-                    parameters=tool_class.get_parameters(),
+        # 2026-06-08: per-tool isolation. Previously a single tool with a
+        # broken run() annotation (e.g. bare AsyncGenerator) raised
+        # TypeError from get_parameters() and crashed the entire LLM
+        # call — model got an empty tool list and the session save died.
+        # Now: skip the broken tool with a logged warning, continue with
+        # the rest. One bad tool ≠ a dead session.
+        out: list[AvailableTool] = []
+        for tool_class in tool_manager.available_tools.values():
+            try:
+                out.append(AvailableTool(
+                    function=AvailableFunction(
+                        name=tool_class.get_name(),
+                        description=tool_class.description,
+                        parameters=tool_class.get_parameters(),
+                    )
+                ))
+            except Exception as e:
+                # Defensive log; the tool is now invisible to the model
+                # for this turn, but the session keeps going.
+                from drydock.core.logger import logger
+                logger.error(
+                    "[get_available_tools] skipping tool %r: %s",
+                    getattr(tool_class, "__name__", tool_class), e,
                 )
-            )
-            for tool_class in tool_manager.available_tools.values()
-        ]
+        return out
 
     def get_tool_choice(self) -> StrToolChoice | AvailableTool:
         return "auto"

{drydock_cli-2.10.5 → drydock_cli-2.10.7}/drydock/core/prompts/gemma4_slim.md

@@ -34,6 +34,8 @@ WHEN TO USE retrieve (project's GraphRAG index):
 
 If the user asks to "set up GraphRAG" / "configure RAG" / "is the cookbook indexed?", run `bash` with `python3 -m drydock.graphrag setup` — it auto-detects bundled + local cookbooks and ingests them. No-op safe to re-run. To confirm afterward, run `python3 -m drydock.graphrag stats`.
 
+If the user asks to ingest a folder with PDFs (or specific files), run `bash` with `python3 -m drydock.graphrag ingest <path>`. The ingester handles `.py`, `.md`/`.markdown`, `.rst`, `.txt`, and `.pdf` (via pypdf). Image-only/scanned PDFs are silently skipped.
+
 WHEN TO USE WEB TOOLS (sparingly):
 - Stuck on an error you've tried to fix 2+ times: `web_search` for the exact error message
 - Need an API example you don't remember: `web_search`

{drydock_cli-2.10.5 → drydock_cli-2.10.7}/drydock/core/session/session_logger.py

@@ -298,18 +298,31 @@ class SessionLogger:
             messages_data = [m.model_dump(exclude_none=True) for m in new_messages]
             await SessionLogger.persist_messages(messages_data, self.session_dir)
 
-            # If message update succeeded, write metadata
-            tools_available = [
-                {
-                    "type": "function",
-                    "function": {
-                        "name": tool_class.get_name(),
-                        "description": tool_class.description,
-                        "parameters": tool_class.get_parameters(),
-                    },
-                }
-                for tool_class in tool_manager.available_tools.values()
-            ]
+            # If message update succeeded, write metadata.
+            # 2026-06-08: per-tool isolation — same defensive pattern as
+            # format.get_available_tools. A single tool with a broken
+            # run() annotation used to crash session save (and through
+            # save_interaction's re-raise, the whole TUI session). Skip
+            # broken tools with a logged warning; the session metadata
+            # just lacks those entries.
+            tools_available = []
+            for tool_class in tool_manager.available_tools.values():
+                try:
+                    tools_available.append({
+                        "type": "function",
+                        "function": {
+                            "name": tool_class.get_name(),
+                            "description": tool_class.description,
+                            "parameters": tool_class.get_parameters(),
+                        },
+                    })
+                except Exception as tool_err:
+                    from drydock.core.logger import logger
+                    logger.error(
+                        "[session_logger] skipping broken tool %r: %s",
+                        getattr(tool_class, "__name__", tool_class),
+                        tool_err,
+                    )
 
             title = self._get_title(messages)
             system_prompt = (

drydock_cli-2.10.7/drydock/data/cookbook/python/global_rename.md

@@ -0,0 +1,134 @@
+# Global rename across modules — fields, functions, or public API
+
+For pure identifier renames across multiple `.py` files, use `mechanical_rename(old_name, new_name, scope, kind)` — it applies the rename atomically, runs pytest, and rolls back if the suite goes red. One call replaces 5–8 manual edits. `kind` is `"function"`, `"class"`, `"field"` (also rewrites dict-key string literals), or `"auto"`.
+
+For renames that touch non-Python files, README, `__all__`, or require judgment on what to skip, fall back to the manual `search_replace` (or `sed -i 's/\boldname\b/newname/g'` via bash) file-by-file process described below.
+
+Three flavors:
+- **Internal field rename**: rename `oldname → newname` across schema, transforms, aggregate, pipeline, and tests.
+- **Public function rename**: rename `old_func → new_func` in source AND every test AND every import AND `__init__.__all__` AND README/CHANGELOG.
+- **Class rename**: similar to public function — touches imports, type annotations, tests.
+
+All are "rename everywhere" tasks. The harness check is usually "no occurrence of the old name remains anywhere in the package". One straggler = fail.
+
+## For PUBLIC function/class renames specifically
+
+A public-API rename touches MORE places than an internal field:
+
+1. **Source definition** — `def newname(...)` (was `def oldname`).
+2. **All call sites** in the same module AND other modules: `grep -rn '\boldname\b' pkg/` to find them.
+3. **`__init__.py` re-exports** — `__init__.__all__` must list `"newname"` not `"oldname"`. Also any `from .x import oldname as oldname` must change to import the new name.
+4. **Every test file** — both the import line AND every assertion that referenced the old name.
+5. **README + CHANGELOG** — operator-facing docs. Search for the old name in `*.md`.
+6. **No backwards-compat alias by default** — the prompt says "full rename"; don't keep `oldname = newname` for compat unless explicitly asked.
+
+After the rename, this command should print **NOTHING**:
+
+```bash
+grep -rn '\boldname\b' pkg/ tests/ README.md CHANGELOG.md 2>/dev/null
+```
+
+If anything shows up, that's the straggler that fails the case.
+
+## Disciplined process
+
+1. **Map the footprint** before editing. Count occurrences:
+
+   ```bash
+   grep -rn '\boldname\b' pkg/ tests/   # word-boundary anchored
+   ```
+
+   The `\b` matters: `oldname` should NOT match `oldname_test`, `newname_oldname` etc. If your tool can't do `\b`, use `'\\boldname\\b'` or pipe through `grep -wn`.
+
+2. **Decide what's in scope.** The prompt usually scopes to the *internal* identifier, not user-facing copy. So:
+
+   - YES rename: source code references, function args, schema keys, column names in code.
+   - YES rename: test fixtures + assertions that reference the old name.
+   - Maybe NOT: fixture data files (depends on prompt). Re-read it.
+   - Maybe NOT: README, docstrings (depends on prompt — these are user-facing).
+
+   When in doubt, rename everything that the harness can grep, because the check usually looks at every `.py` file under the package.
+
+3. **Rename, file by file**, top of the dependency tree first.
+
+   For each file: `search_replace` the old name → new name. If using `sed`:
+
+   ```bash
+   sed -i 's/\boldname\b/newname/g' pkg/module.py
+   ```
+
+4. **Verify nothing was missed**:
+
+   ```bash
+   grep -rn '\boldname\b' pkg/ tests/ 2>/dev/null
+   # should print NOTHING (except in fixture data files you intentionally left alone)
+   ```
+
+5. **If a data fixture also uses the old name** — decide based on the prompt:
+   - Prompt says "rename internal only" → keep the data file as-is, rename to the new name at the read boundary:
+
+     ```python
+     def read_input(path, ...):
+         rows = []
+         with open(path) as f:
+             reader = csv.DictReader(f)
+             for src in reader:
+                 row = dict(src)
+                 if "oldname" in row:
+                     row["newname"] = row.pop("oldname")     # rename at the boundary
+                 rows.append(row)
+         return rows
+     ```
+
+   - Prompt says "rename everywhere including data" → also rewrite the data file.
+
+6. **Re-run the test suite**. The renamed tests should still pass; existing tests that don't reference the old name are unaffected.
+
+   ```bash
+   pytest -q
+   ```
+
+## Completeness check
+
+```bash
+# (1) Source files are clean of the old name
+grep -rn '\boldname\b' pkg/ && echo "BUG: still references"
+# (2) New name appears everywhere old name did
+grep -rn '\bnewname\b' pkg/ tests/ | wc -l
+# (3) Tests pass
+pytest -q
+# (4) Re-test end-to-end
+python3 -m pkg run                                  # should work
+```
+
+The harness check usually looks for:
+- `grep '\boldname\b' pkg/module.py` is empty AFTER the rename (and same for related files).
+- `grep '\bnewname\b'` finds the new name in those same files.
+- `green(N)` — the test suite stays green.
+
+If any of those is wrong, the rename is incomplete.
+
+## Common straggler locations
+
+| Place | Why it's easy to miss |
+| --- | --- |
+| Default value in a function signature | `def f(x, default_oldname=0)` — the kwarg has the old name |
+| Error/log strings | `raise ValueError(f"oldname must be int, got {oldname!r}")` |
+| Dict keys in `__init__` | `self._fields = {"oldname": int, ...}` |
+| Docstrings | If the doc says "the oldname column", grep won't filter docstrings out |
+| Tests' SETUP data | `data = [{"oldname": 5}, {"oldname": 7}]` |
+
+Run `grep -rn '\boldname\b'` AFTER the rename and inspect every remaining hit. Either rename it or document why it stays.
+
+## Don't grep in fixture data unless the prompt says so
+
+If a CSV or JSON fixture file has the column header / field name `oldname`, whether to rewrite it is a JUDGMENT CALL based on the prompt:
+
+- "rename internal field" → leave the fixture data alone
+- "rename everywhere including data" → rewrite the fixture (NOT the column values — those are unrelated)
+
+For the safer interpretation, leave the fixture alone and rename `oldname` → `newname` only at the read boundary as shown above. This means the fixture is untouched (no "data drift" failure) and the in-memory representation uses the new name.
+
+## Don't use `replace_all` blindly
+
+`search_replace` with `replace_all` is fast but dangerous: it might rename `oldname_helper` to `newname_helper` accidentally. Always combine with word-boundary regex (`\boldname\b`) or do them file-by-file and read the diff.

drydock_cli-2.10.7/drydock/data/cookbook/tbench_domains/elf_extraction_js.md

@@ -0,0 +1,165 @@
+# ELF binary memory extraction with Node.js
+
+Used by: `extract-elf`. Task gives an `a.out` compiled C binary and
+asks for an `extract.js` that, when invoked as
+`node extract.js /app/a.out > out.json`, outputs a JSON object
+mapping virtual-memory addresses (as numeric strings) to the
+integer values at those addresses.
+
+Pass requires ≥75% of the reference solution's address coverage,
+and every emitted address must match the reference value (no
+false positives).
+
+## What "memory values" means here
+
+The reference solution reads the bytes of each LOAD segment from
+the ELF file at its declared virtual address. For each 4-byte
+aligned word in the loadable segments, it emits
+`{ "<virt_addr>": <int32_le_value> }`.
+
+So the work is:
+1. Parse the ELF header (64-byte fixed layout for ELF64).
+2. Find the Program Header Table (PHT) — `e_phoff`, `e_phentsize`,
+   `e_phnum` fields in the ELF header.
+3. For each program header with `p_type == PT_LOAD (1)`:
+   - read `p_offset` (file offset), `p_vaddr` (virtual address),
+     `p_filesz` (bytes to read), `p_flags`
+4. Read `p_filesz` bytes from the file starting at `p_offset`.
+5. For each 4-byte word, emit `vaddr+i → uint32_le_value`.
+
+## ELF64 header layout (the bytes we care about)
+
+```
+offset  size  field         meaning
+0       16    e_ident       magic + class + endian
+0       4     ELF magic     0x7F 'E' 'L' 'F'
+4       1     EI_CLASS      1=ELF32, 2=ELF64
+5       1     EI_DATA       1=little-endian, 2=big-endian
+...
+24      8     e_entry       entry-point vaddr
+32      8     e_phoff       file offset of program-header table
+40      8     e_shoff       file offset of section-header table
+48      4     e_flags
+52      2     e_ehsize      header size (64 for ELF64)
+54      2     e_phentsize   each PHT entry size (56 for ELF64)
+56      2     e_phnum       number of PHT entries
+58      2     e_shentsize
+60      2     e_shnum
+62      2     e_shstrndx
+```
+
+## ELF64 program header entry (56 bytes)
+
+```
+offset  size  field
+0       4     p_type      1 = LOAD (the only one we care about)
+4       4     p_flags
+8       8     p_offset    file offset
+16      8     p_vaddr     virtual address
+24      8     p_paddr     physical address (usually = p_vaddr)
+32      8     p_filesz    bytes to read from file
+40      8     p_memsz     bytes in memory (may > filesz for BSS)
+48      8     p_align
+```
+
+## Reference-shaped Node.js implementation
+
+```javascript
+#!/usr/bin/env node
+const fs = require('fs');
+
+const path = process.argv[2];
+if (!path) { console.error('usage: node extract.js <elf>'); process.exit(1); }
+const buf = fs.readFileSync(path);
+
+// Sanity check ELF magic + 64-bit + little-endian
+if (buf.readUInt32BE(0) !== 0x7F454C46) {
+    console.error('not an ELF binary'); process.exit(1);
+}
+const ei_class = buf.readUInt8(4); // 2 = ELF64
+const ei_data  = buf.readUInt8(5); // 1 = little-endian
+if (ei_class !== 2 || ei_data !== 1) {
+    console.error('only ELF64 little-endian supported'); process.exit(1);
+}
+
+// Header fields (ELF64 layout)
+const e_phoff     = Number(buf.readBigUInt64LE(32));
+const e_phentsize = buf.readUInt16LE(54);
+const e_phnum     = buf.readUInt16LE(56);
+
+const out = {};
+
+for (let i = 0; i < e_phnum; i++) {
+    const ph = e_phoff + i * e_phentsize;
+    const p_type   = buf.readUInt32LE(ph + 0);
+    if (p_type !== 1) continue;  // skip non-LOAD
+    const p_offset = Number(buf.readBigUInt64LE(ph + 8));
+    const p_vaddr  = Number(buf.readBigUInt64LE(ph + 16));
+    const p_filesz = Number(buf.readBigUInt64LE(ph + 32));
+
+    // Emit 4-byte words. The reference emits little-endian int32 values
+    // (the JSON expects unsigned 32-bit ints — `>>> 0` forces unsigned).
+    for (let off = 0; off + 4 <= p_filesz; off += 4) {
+        const vaddr = p_vaddr + off;
+        const value = buf.readUInt32LE(p_offset + off);
+        out[String(vaddr)] = value;
+    }
+}
+
+process.stdout.write(JSON.stringify(out));
+```
+
+## Pitfalls that cost passes
+
+1. **Big-endian vs little-endian**: `extract-elf` ships an x86_64
+   binary → little-endian. Use `readUInt32LE`, not BE. Emitting
+   the wrong endianness fails every assertion silently.
+2. **Signed vs unsigned int32**: JSON allows arbitrary integers but
+   the task's reference treats values as **unsigned**. Use
+   `readUInt32LE`, or apply `>>> 0` to a signed read.
+3. **Address as STRING key, value as NUMBER**: The reference output
+   has string keys (`"4194304"`) but numeric values. Mixing them
+   (e.g., `out[String(vaddr)] = String(value)`) fails the value-
+   type check.
+4. **Don't emit p_memsz beyond p_filesz** — those are BSS (zero-
+   initialized at load time, not present in file). The reference
+   doesn't emit them.
+5. **Step size 4, not 1**: emitting per-byte values would (a) blow
+   up the JSON size, (b) wouldn't match the reference. 4 byte
+   alignment is the contract.
+6. **Don't include section-header LOAD-like data** — only PT_LOAD
+   program headers, not sections.
+7. **Address arithmetic in JS**: `p_vaddr + off` can exceed
+   Number.MAX_SAFE_INTEGER for some binaries (uncommon). If tests
+   reject huge addresses, switch to BigInt and stringify.
+
+## How the verifier checks correctness
+
+- Loads the reference solution's `out.json`.
+- For each address in YOUR output:
+  - If address is in the reference: value must match.
+  - If address is NOT in the reference: silently ignored
+    (extra addresses don't hurt; can help coverage).
+- Counts addresses present in BOTH yours and reference; pass
+  requires ≥ 75% of reference addresses covered.
+
+So the conservative strategy is: emit the entire `.text`, `.rodata`,
+and any other R/RX LOAD segments as 4-byte words. If unsure of an
+address, emit it — extra entries don't penalize you, missing
+entries do.
+
+## Common task shape variants
+
+The task occasionally ships a stripped binary (no section headers)
+— that's fine, this approach uses program headers, not sections,
+so it works regardless of stripping.
+
+For ELF32 binaries (`ei_class == 1`), the layout shifts to
+32-bit fields:
+- e_phoff at offset 28 (4 bytes), e_phentsize at offset 42
+- PHT entry: p_type(4), p_offset(4), p_vaddr(4), p_paddr(4),
+  p_filesz(4), p_memsz(4), p_flags(4), p_align(4) — 32 bytes
+  total
+
+`extract-elf` ships ELF64 by default but a defensive impl handles
+both.