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

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.10.6
-Summary: Local-first CLI coding agent — tested with Gemma 4 26B via llama.cpp
+Version: 2.10.8
+Summary: Local-first TUI coding agent for Gemma 4 + llama.cpp, with GraphRAG retrieval and a curated cookbook of domain recipes.
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock
 Project-URL: Issues, https://github.com/fbobe321/drydock/issues

{drydock_cli-2.10.6 → drydock_cli-2.10.8}/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.6 → drydock_cli-2.10.8}/drydock/core/agent_loop.py

@@ -7255,9 +7255,24 @@ class AgentLoop:
             except ValueError:
                 _bypass_thresh = 25.0
             # Cheap probe — short query, just enough to read the top score.
+            #
+            # 2026-06-09: strip the harness wrapper from the probe query.
+            # tbench / harbor prompts open with ~600 chars of "WRITE-FIRST
+            # RULE / Process to follow" boilerplate followed by
+            # "----- Task: -----" then the actual task. Using the raw
+            # message made global_rename.md (which contains "tool call",
+            # "rename", "process") score 51.4 — beating the FEAL-specific
+            # cookbook — on a FEAL trial, so the injection was pure noise
+            # that caused an empty model response and 43s session exit.
             try:
                 from drydock.graphrag import Index as _Probe
-                _probe_query = (user_msg or "").strip()[:300]
+                _raw_for_probe = user_msg or ""
+                _task_marker = _raw_for_probe.find("----- Task: -----")
+                if _task_marker >= 0:
+                    _raw_for_probe = _raw_for_probe[
+                        _task_marker + len("----- Task: -----"):
+                    ]
+                _probe_query = _raw_for_probe.strip()[:300]
                 if _probe_query:
                     _env_db = os.environ.get("DRYDOCK_GRAPHRAG_DB")
                     _home_db = str(Path.home() / ".drydock" / "graphrag.sqlite")

drydock_cli-2.10.8/drydock/data/cookbook/tbench_domains/mcmc_stan.md

@@ -0,0 +1,188 @@
+# MCMC sampling with Stan (RStan / PyStan)
+
+Used by: `mcmc-sampling-stan`, `rstan-to-pystan`. Task asks for a
+Bayesian hierarchical model fit via MCMC sampling, usually with a
+specific model file (`.stan`) and a specific package (RStan or
+PyStan/CmdStanPy). Output: posterior means written to plaintext
+files.
+
+Currently flaky-pass (2/6 = 33% for mcmc-sampling-stan).
+
+## Stan model file structure
+
+A Stan model has 3-4 standard blocks:
+
+```stan
+data {
+    int<lower=0> N;            // n observations
+    vector[N] y;               // observed outcomes
+}
+parameters {
+    real alpha;
+    real<lower=0> sigma;
+}
+model {
+    alpha ~ normal(0, 10);     // priors
+    sigma ~ exponential(1);
+    y ~ normal(alpha, sigma);  // likelihood
+}
+```
+
+The file is human-readable and can be inspected with `cat` if the
+task provides it.
+
+## The R + RStan path (preferred when task asks for R)
+
+```r
+library(rstan)
+options(mc.cores = parallel::detectCores())
+rstan_options(auto_write = TRUE)
+
+# Build the data list from CSV / pre-computed numbers
+data_list <- list(
+  N = nrow(my_df),
+  y = my_df$y,
+  x = my_df$x
+)
+
+# Fit. iter=2000 + warmup=1000 + chains=4 is the canonical setting.
+fit <- stan(
+  file = "/app/model.stan",
+  data = data_list,
+  iter = 2000, warmup = 1000, chains = 4, seed = 42
+)
+
+# Extract posterior summaries
+post <- extract(fit)
+alpha_mean <- mean(post$alpha)
+beta_mean  <- mean(post$beta)
+
+# Task usually expects single-number output files:
+writeLines(sprintf("%.6f", alpha_mean), "/app/posterior_alpha_mean.txt")
+writeLines(sprintf("%.6f", beta_mean),  "/app/posterior_beta_mean.txt")
+```
+
+## The Python + CmdStanPy path (preferred when task asks for Python)
+
+PyStan 3 dropped Windows support and has many install issues;
+**CmdStanPy is the better choice** for tbench. It calls the CmdStan
+binary directly:
+
+```python
+import cmdstanpy
+# CmdStan must be installed; on first run it downloads + builds itself
+cmdstanpy.install_cmdstan(progress=False)
+
+model = cmdstanpy.CmdStanModel(stan_file="/app/model.stan")
+
+fit = model.sample(
+    data={"N": len(y), "y": y.tolist(), "x": x.tolist()},
+    iter_sampling=1000,
+    iter_warmup=1000,
+    chains=4,
+    seed=42,
+    show_progress=False,
+)
+
+post = fit.stan_variables()  # dict: param name → np.ndarray
+import numpy as np
+alpha_mean = float(np.mean(post["alpha"]))
+beta_mean  = float(np.mean(post["beta"]))
+
+with open("/app/posterior_alpha_mean.txt", "w") as f:
+    f.write(f"{alpha_mean:.6f}\n")
+with open("/app/posterior_beta_mean.txt", "w") as f:
+    f.write(f"{beta_mean:.6f}\n")
+```
+
+## Common task shape: hierarchical model
+
+Two-level groups (e.g., students within schools), random
+intercepts/slopes:
+
+```stan
+data {
+    int<lower=0> N;            // total observations
+    int<lower=0> J;            // number of groups
+    array[N] int<lower=1,upper=J> group;
+    vector[N] y;
+    vector[N] x;
+}
+parameters {
+    real alpha;                       // grand intercept
+    real beta;                        // grand slope
+    real<lower=0> tau_a;              // group intercept SD
+    vector[J] a_offset;               // standardized per-group intercept
+    real<lower=0> sigma;
+}
+transformed parameters {
+    vector[J] a = alpha + tau_a * a_offset;  // non-centered param
+}
+model {
+    alpha ~ normal(0, 10);
+    beta  ~ normal(0, 10);
+    tau_a ~ exponential(1);
+    a_offset ~ normal(0, 1);
+    sigma ~ exponential(1);
+    y ~ normal(a[group] + beta * x, sigma);
+}
+```
+
+**Non-centered parameterization** (the `a_offset → a` trick) is
+critical for hierarchical models with small per-group counts. Without
+it, MCMC mixing is terrible and means are unreliable.
+
+## Pitfalls that cost passes
+
+1. **Wrong chain/iter settings** — too-few iters (100) gives noisy
+   posteriors; the verifier compares to a reference run with 4000+
+   samples. Use 2000+ samples per chain, 4 chains.
+2. **Forgot warmup** — first 1000 samples are burn-in. Defaults
+   handle this, but if you override iter without setting warmup,
+   you lose half your good samples.
+3. **Stan compiler errors** — Stan compiles to C++. Compile errors
+   show as cryptic syntax messages. Check `print(fit.diagnose())`
+   after `model.sample()`.
+4. **Divergent transitions** — symptom of bad parameterization
+   (e.g., centered hierarchical model with small groups). Stan warns;
+   the verifier ignores them but the resulting posterior is biased.
+5. **Wrong output format** — task might want JSON, single-number
+   plaintext, or per-line param=value. Read carefully.
+6. **R vs Python mismatch** — if task says "use RStan", a CmdStanPy
+   solution won't pass even with identical posteriors.
+7. **Group indexing 0 vs 1** — Stan is 1-indexed. If you pass
+   Python 0-indexed group labels, the model crashes on access.
+8. **Data list keys** — Stan's `data` block declares variable names
+   that must match the data dict keys exactly. A typo silently
+   doesn't pass that variable.
+
+## Verifying the fit
+
+```python
+print(fit.diagnose())  # Stan's own check — divergent transitions, R-hat, etc.
+print(fit.summary())   # Per-param mean, sd, R-hat, ESS
+# R-hat near 1.0 (within 0.01) means chains converged
+# ESS > 100 per chain means enough effective samples
+```
+
+R-hat > 1.05 or ESS < 100 → fit is bad; results may not match the
+reference. Increase chains or iter to fix.
+
+## Install-time gotchas
+
+For Python:
+```bash
+pip install cmdstanpy
+python -c "import cmdstanpy; cmdstanpy.install_cmdstan(progress=False)"
+```
+
+For R:
+```bash
+R -e 'install.packages("rstan", repos="https://cloud.r-project.org")'
+# OR (preferred since rstan 2.32+):
+R -e 'install.packages("cmdstanr", repos = c("https://stan-dev.r-universe.dev"))'
+R -e 'cmdstanr::install_cmdstan()'
+```
+
+Install can take 5-10 minutes; PyStan 3 in particular sometimes
+fails with cython linker errors — fall back to CmdStanPy.

drydock_cli-2.10.8/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.