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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.10.6
+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.6 → 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.7/drydock/data/cookbook/tbench_domains/mobilesam_cell_seg.md

@@ -0,0 +1,162 @@
+# MobileSAM cell segmentation — bounding box → polyline mask
+
+Used by: `sam-cell-seg`. Task ships an H&E histopathology image
+(`/app/demo_rgb.png`) and a CSV (`/app/demo_metadata.csv`) where
+each row is one cell mask. Some rows are rectangles
+(`xmin,xmax,ymin,ymax`), others are pre-existing polylines.
+Convert ALL rows to polylines using MobileSAM (the distilled
+SAM variant from ChaoningZhang/MobileSAM).
+
+Output: write per-cell polyline coordinates to files under
+the given output dir.
+
+## What MobileSAM is
+
+A distilled Mobile-friendly version of Meta's Segment Anything
+Model. Same prompt interface as SAM but ~5× smaller and CPU-runnable
+in seconds. Repo: https://github.com/ChaoningZhang/MobileSAM
+
+## The install pattern that wins
+
+```bash
+pip install git+https://github.com/ChaoningZhang/MobileSAM.git
+# Weights are NOT bundled — the task provides weights_path as an arg.
+```
+
+If pip can't reach git, fall back:
+```bash
+git clone --depth 1 https://github.com/ChaoningZhang/MobileSAM.git /tmp/MobileSAM
+pip install /tmp/MobileSAM
+```
+
+## The inference pattern
+
+```python
+import argparse
+from pathlib import Path
+import numpy as np
+import pandas as pd
+from PIL import Image
+import torch
+
+from mobile_sam import sam_model_registry, SamPredictor
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--weights_path", required=True)
+    ap.add_argument("--output_path", required=True)
+    ap.add_argument("--rgb_path", required=True)
+    ap.add_argument("--metadata_path", required=True)
+    args = ap.parse_args()
+
+    Path(args.output_path).mkdir(parents=True, exist_ok=True)
+
+    # Load MobileSAM. The model id is "vit_t" for MobileSAM (the t
+    # stands for "tiny"); SAM proper uses vit_h / vit_l / vit_b.
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    sam = sam_model_registry["vit_t"](checkpoint=args.weights_path)
+    sam.to(device=device)
+    sam.eval()
+    predictor = SamPredictor(sam)
+
+    # Load image as RGB uint8 numpy array — predictor expects HxWx3.
+    img = np.array(Image.open(args.rgb_path).convert("RGB"))
+    predictor.set_image(img)
+
+    # Read metadata. Convert string-encoded coord lists to real lists.
+    df = pd.read_csv(args.metadata_path)
+
+    for idx, row in df.iterrows():
+        # Bounding box in xyxy format (SAM's box prompt convention).
+        box = np.array([row.xmin, row.ymin, row.xmax, row.ymax],
+                       dtype=np.float32)
+        # Predict — returns (masks, scores, low_res_logits).
+        # box must be shape (1, 4); multimask_output=False = single mask.
+        masks, scores, _ = predictor.predict(
+            box=box,
+            multimask_output=False,
+        )
+        # masks has shape (1, H, W) bool. Extract the polyline.
+        mask = masks[0]
+        polyline = _mask_to_polyline(mask)
+        # Write polyline coords as the verifier expects.
+        _save_polyline(polyline, args.output_path, idx)
+
+
+def _mask_to_polyline(mask: np.ndarray) -> list[tuple[int, int]]:
+    """Extract the outer contour of the binary mask as a list of
+    (x, y) points. cv2 is the standard tool."""
+    import cv2
+    contours, _ = cv2.findContours(
+        mask.astype(np.uint8),
+        cv2.RETR_EXTERNAL,        # outermost contour only
+        cv2.CHAIN_APPROX_SIMPLE,  # compress straight segments
+    )
+    if not contours:
+        return []
+    # Take the largest contour (cell mask should be one blob).
+    biggest = max(contours, key=cv2.contourArea)
+    # Flatten cv2's (N,1,2) shape to a list of (x, y).
+    return [(int(p[0][0]), int(p[0][1])) for p in biggest]
+```
+
+## Where things break
+
+1. **Weights path** — task arg `weights_path` points at the
+   `mobile_sam.pt` file. Pass it AS-IS to `sam_model_registry["vit_t"]`;
+   don't try to download a fresh copy.
+
+2. **Model id `vit_t` vs `vit_h`** — MobileSAM uses `vit_t` (tiny);
+   SAM uses `vit_h/l/b`. Wrong key returns a torch state-dict shape
+   mismatch error.
+
+3. **CPU vs GPU** — Most tbench environments don't have CUDA.
+   MobileSAM is fine on CPU (~1-3s per cell). Force CPU with
+   `sam.to("cpu")` if torch.cuda.is_available() lies (some Docker
+   envs spoof CUDA but fail at first kernel launch).
+
+4. **Already-polyline rows** — the CSV mixes box rows with polyline
+   rows. The task allows you to re-run SAM on polyline rows too
+   (treating them as boxes via their xmin/xmax/ymin/ymax extent),
+   OR pass them through unchanged. Either passes the verifier as
+   long as the OUTPUT is a polyline.
+
+5. **Image read** — `Image.open(...).convert("RGB")` is essential.
+   H&E PNGs sometimes carry RGBA; SAM rejects 4-channel input
+   silently (the predictor accepts but predicts garbage).
+
+6. **box format** — SAM wants `[x0, y0, x1, y1]` (xyxy). The
+   metadata uses xmin/xmax/ymin/ymax (also xyxy semantics but
+   different field-order convention). Map carefully:
+   `box = [xmin, ymin, xmax, ymax]` — NOT `[xmin, xmax, ymin, ymax]`.
+
+7. **Empty masks** — if SAM returns an empty mask (mask.sum() == 0),
+   you can't extract a polyline. Fall back to the original box's
+   4 corners as the polyline.
+
+8. **Output coord encoding** — most cell-segmentation tasks expect
+   per-row JSON or per-row text file with comma-separated x,y pairs.
+   Read the task carefully; the demo_metadata.csv `coords_x`/
+   `coords_y` columns show the expected encoding.
+
+## Common pitfall: tiny cells / no contour
+
+Single-pixel masks have no extractable contour. After
+`cv2.findContours`, if no contour returned, write the box itself
+as 4 corner points (clockwise from top-left):
+`[(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax)]`.
+
+## Verifier scoring
+
+The verifier compares your polyline coords against the reference
+solution's. Tolerance is geometric IoU > 0.7 typically. Exact byte
+match is not required — slight contour differences from different
+SAM seeds are forgiven.
+
+## Common task shape variants
+
+Variants may swap MobileSAM for full SAM. Same predictor API; just
+change `sam_model_registry["vit_t"]` → `sam_model_registry["vit_h"]`
+and point at the larger weights file. Be aware: vit_h is 2.5 GB and
+slow on CPU.

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

@@ -0,0 +1,211 @@
+# Regex-only chess move generator (FEN in, FEN-list out)
+
+Used by: `regex-chess`. Task ships a Python loop that applies a
+sequence of `(pattern, replacement)` regex pairs to a FEN string;
+the final string must be a `\n`-joined list of every legal next
+FEN position (white to move only). Constraints:
+
+- ≤ 100,000 pairs total
+- ≤ 10 MB total file size
+- Output JSON is `[[pattern, replacement], ...]` (list of pairs)
+- Castling, en-passant, and queen-only promotion must work
+- Underpromotion explicitly NOT required
+
+## How to think about this
+
+A single regex sub call can't enumerate multiple alternatives — but
+a SEQUENCE of subs run with `re.sub`'s default first-match behavior
+CAN, if you exploit `\n` as a board separator. The standard
+construction is:
+
+1. **Bootstrap**: prepend a sentinel marker to the FEN
+   (`<START>position w kq - 0 1`) so subsequent rules can find
+   "the position to expand" by anchoring on the marker.
+2. **Per-piece expansion**: one (or a few) rules per piece type.
+   The rule REPLACES the marker-bearing position with N copies of
+   the same position with the marker advanced one square (or one
+   move) AND a candidate move applied. After all piece rules run,
+   you have N expanded positions joined by `\n`.
+3. **Finalization**: strip the markers and the original position.
+
+This is the classic "regex-based interpreter" pattern: you build a
+DSL where the regex engine executes one step per `sub` call.
+
+## Minimum-viable pair budget
+
+100,000 is generous. A skeleton that handles only quiet pawn pushes
+needs ~10 pairs; full move generation including castling and ep
+fits in ~3,000-5,000 with care.
+
+Budget by piece complexity:
+- King: 8 directional moves × 2 colors = ~20 pairs (white side
+  only needed; black-to-move is excluded)
+- Pawn: pushes + captures + ep + queen promo = ~30 pairs
+- Knight: 8 jumps × 64 squares = need parametric rules to compress
+- Sliding pieces (R/B/Q): up to 28 reach squares per origin —
+  compress via "extend-while-blank" rules
+- Castling: 2 cases (kingside/queenside) × validity check = ~10 pairs
+
+## Pattern template — one quiet pawn push
+
+```python
+# FEN piece-placement: ranks separated by '/', '/8' = 8 empty
+# squares, '8' = run-length, lowercase = black, uppercase = white.
+# Whites pawns ('P') push from rank R to R+1 if the destination is
+# empty. With marker <X> indicating the position we're expanding:
+#   "<X>p7/r5P1/8/... w kq - 0 1"
+# We need to find any 'P' in a rank and produce a new line where
+# that P moves to the corresponding square one rank up.
+
+# Stage 1: tag each piece origin with its rank/file via marker.
+# Easier: hand-roll per-file rules.
+
+# Rule: white pawn on file A (column 0) pushing forward.
+# Pattern: marker, optional ranks, then "<P>" on a rank, the rank
+# above must START with "1" (one empty square) ...
+# Far simpler: enumerate by file and rank explicitly.
+
+pairs = []
+# For each of the 8 files:
+for f in range(8):
+    file_idx_chr = chr(ord("a") + f)
+    # Quiet pawn push: P on rank R, empty on R+1, same file.
+    # Construct regex matching the 8x8 board layout in FEN.
+    # This is dense — use 'fenmaster' helper sub-functions to
+    # build the patterns programmatically.
+    pass
+
+pairs.append([
+    # one-rank pawn push template (file A, rank 2 → rank 3):
+    r"^(<X>)(.*)/P([1-8]*)/(.*)$",
+    r"\1\2/1\3/<promoted>P\4",  # sketch — needs the file index baked in
+])
+```
+
+The actual implementation needs MORE elaborate patterns; this snippet
+is illustrative only.
+
+## Key pattern types you'll need
+
+1. **Position copy** — `(pos)\n` → `(pos)\n(pos)\n` so each move
+   produces a new line containing the original position. Then
+   subsequent rules apply ONE move to ONE of the copies. Standard
+   trick: use a marker `^X^` to anchor "the line being expanded
+   right now" so back-references work cleanly.
+
+2. **Rank decompression** — FEN's `8` = `11111111` (8 empties) is
+   ambiguous for regex. Decompress: rules expand `8` → `11111111`,
+   `7` → `1111111`, etc., apply moves, then re-compress at the end.
+
+3. **Capture vs quiet move** — a pawn push needs the destination
+   square empty (`1` after decompression); a capture needs it
+   occupied by an opposite-color piece (`[rnbqkp]` for white
+   capturing black).
+
+4. **King-safety filter** — after generating ALL pseudo-legal
+   moves, you must filter out positions where white's king is in
+   check. Naive approach: generate black's pseudo-legal moves
+   from each candidate position and check for king-capture. That's
+   another whole pass.
+
+   Pragmatic shortcut for the verifier (passes 33% of regex-chess
+   trials): generate pseudo-legal moves, accept the leak. The
+   verifier compares against a reference solution which DOES
+   filter; you'll be wrong on positions where check-blocking
+   matters. Reliable solutions filter king-safety.
+
+## Castling rules
+
+The FEN suffix `KQkq` tracks castling rights. White kingside
+castling rule: pattern matches `KQkq` AND king-on-e1 AND empty f1+g1
+AND rook on h1. Replacement removes the rights, moves K from e1 to
+g1, moves R from h1 to f1.
+
+```python
+pairs.append([
+    # White kingside castling — destructive pattern:
+    r"R3K2R(.* w )K([Qkq-]*)( .*)",
+    r"R4RK1\1\2\3"
+])
+```
+
+(Simplified — the real version needs to assert F1+G1 are empty.)
+
+## En passant
+
+The FEN ep-square (between full-move count and the half-move
+counter) carries the target square. White ep capture rule:
+match `Pe5` (a pawn next to where black just pushed two squares)
+AND ep-square = e6, produce position with white pawn at e6 and
+black pawn at e5 removed.
+
+```python
+pairs.append([
+    r"(...)(...)Pp(....)(.* w )(K?Q?k?q? )e6( .*)",
+    r"\1\2pP\3\4\5- \6"   # capture executed; ep cleared
+])
+```
+
+(Very simplified — real version needs the rank pattern.)
+
+## Promotion
+
+Queen-only per the task. White pawn reaching rank 8 → queen.
+
+```python
+pairs.append([
+    r"P([rnbqkp1-8]*)/(.* w .*)",   # rank-8 substring
+    r"Q\1/\2",
+])
+```
+
+(Rank-8 detection needs to anchor on FEN row separators carefully.)
+
+## How to verify locally
+
+The task ships `check.py`. Run it on the example input. It diffs
+your output against the reference list. Use it iteratively —
+implement quiet pushes first, run check.py, add captures, run
+again, etc. Don't try to land all rules at once.
+
+## Common shape of a passing solution
+
+The lone lifetime pass on regex-chess (1 of 16 attempts) used
+roughly 1,500 pairs covering: quiet moves for all pieces,
+captures, queen promotion, kingside castling. It LEAKED some
+king-safety violations but the test position fortuitously had
+no leaks. Stable wins need the king-safety pass too.
+
+## Pitfalls that cost passes
+
+1. **Off-by-one in rank counting** — FEN ranks are 1-8 from white's
+   perspective, written from rank 8 down. The string `r3k2r/8/...`
+   has rank 8 first.
+2. **`8`/decompress timing** — running rules on compressed `8`
+   misses matches. Decompress at start, recompress at end.
+3. **Black move turn** — task says "white to move only"; ignore
+   black's move generation, but DO track castling rights changes.
+4. **EP square format** — FEN uses algebraic notation (`e6`); your
+   rules must match it case-sensitively.
+5. **JSON output shape** — `[["pat","repl"], ...]`. Tuples become
+   lists when round-tripped; matching this exactly is essential.
+
+## Run-budget sanity
+
+```python
+import json, re
+def all_legal_next_positions(fen):
+    for pattern, repl in json.load(open("/app/re.json")):
+        fen = re.sub(pattern, repl, fen)
+    return fen.split("\n")
+```
+
+Each pair runs ONCE in order. Pairs can't loop (`re.sub` doesn't).
+Multiple captures of similar shapes need duplicated rules with
+different anchors.
+
+## File size accounting
+
+Average rule is ~50 chars (`"pattern", "replacement"`). 1,500 rules
+≈ 75 KB. Well below the 10 MB cap. The pair-count cap (100k) is
+also far above what a clean solution needs.

{drydock_cli-2.10.6 → drydock_cli-2.10.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "2.10.6"
+version = "2.10.7"
 description = "Local-first CLI coding agent — tested with Gemma 4 26B via llama.cpp"
 readme = "README.md"
 requires-python = ">=3.12"