drydock-cli 3.0.116__tar.gz → 3.0.118__tar.gz

{drydock_cli-3.0.116/drydock_cli.egg-info → drydock_cli-3.0.118}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.116
+Version: 3.0.118
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0

{drydock_cli-3.0.116 → drydock_cli-3.0.118}/drydock/recipes.py

@@ -132,6 +132,119 @@ RECIPES: list[tuple[str, list[str], str]] = [
      "  log f from tangent lines at support points; sample from the hull's exp, accept/\n"
      "  reject, and ADD each rejected point to the hull so it tightens over time.\n"
      "Seed the RNG for reproducibility and validate the sample mean/var against f."),
+
+    ("Classification metrics — accuracy, precision, recall, F1, MCC, ROC/AUC, confusion matrix",
+     ["metric", "metrics", "accuracy", "precision", "recall", "f1", "mcc", "roc",
+      "auc", "confusion", "tp", "fp", "fn", "tn", "classification", "eval",
+      "evaluate", "score", "true", "positive", "negative"],
+     "Given y_true and y_pred (and y_score = P(positive) for ROC):\n"
+     "  from sklearn.metrics import (accuracy_score, precision_score, recall_score,\n"
+     "    f1_score, matthews_corrcoef, roc_auc_score, roc_curve, confusion_matrix)\n"
+     "  acc=accuracy_score(y_true,y_pred); f1=f1_score(y_true,y_pred)\n"
+     "  prec=precision_score(y_true,y_pred); rec=recall_score(y_true,y_pred)\n"
+     "  mcc=matthews_corrcoef(y_true,y_pred); auc=roc_auc_score(y_true,y_score)\n"
+     "  tn,fp,fn,tp = confusion_matrix(y_true,y_pred).ravel()   # BINARY order!\n"
+     "  fpr,tpr,thr = roc_curve(y_true,y_score)   # plot tpr vs fpr; AUC=area\n"
+     "Definitions: precision=TP/(TP+FP), recall=TP/(TP+FN), F1=2PR/(P+R),\n"
+     "MCC=(TP*TN-FP*FN)/sqrt((TP+FP)(TP+FN)(TN+FP)(TN+FN)). Multiclass: pass\n"
+     "average='macro'/'weighted'. Save metrics as JSON; plot ROC with matplotlib\n"
+     "(plt.plot(fpr,tpr); savefig). Watch class order and the positive label."),
+
+    ("PyTorch training / eval loop (correct structure)",
+     ["pytorch", "torch", "train", "training", "model", "loss", "optimizer",
+      "epoch", "cnn", "network", "nn", "fit", "gpu", "cuda", "dataloader"],
+     "  import torch, torch.nn as nn\n"
+     "  dev = 'cuda' if torch.cuda.is_available() else 'cpu'; model.to(dev)\n"
+     "  opt = torch.optim.AdamW(model.parameters(), lr=1e-3)\n"
+     "  loss_fn = nn.CrossEntropyLoss()   # expects raw logits + int class targets\n"
+     "  for epoch in range(E):\n"
+     "    model.train()\n"
+     "    for xb,yb in train_loader:\n"
+     "      xb,yb = xb.to(dev), yb.to(dev)\n"
+     "      opt.zero_grad(); out = model(xb); loss = loss_fn(out, yb)\n"
+     "      loss.backward(); opt.step()\n"
+     "    model.eval()\n"
+     "    with torch.no_grad(): ... # compute val metric, no grad\n"
+     "Gotchas: zero_grad EVERY step; CrossEntropyLoss takes logits (no softmax);\n"
+     "targets are Long class indices; move BOTH model and batch to the same device;\n"
+     "set model.eval() (disables dropout/BN update) for validation. Seed torch for repro."),
+
+    ("LoRA / full fine-tuning with transformers + peft",
+     ["lora", "peft", "finetune", "fine-tune", "fine", "tuning", "adapter",
+      "transformers", "pretrained", "huggingface", "bert", "gpt", "vit", "freeze"],
+     "FULL fine-tune: load a pretrained model, train ALL params on your data with a\n"
+     "small LR (2e-5..5e-5), AdamW, a few epochs; save with model.save_pretrained(dir).\n"
+     "LoRA (train ~0.1% of params): \n"
+     "  from peft import LoraConfig, get_peft_model, TaskType\n"
+     "  cfg = LoraConfig(r=8, lora_alpha=16, lora_dropout=0.05,\n"
+     "                   target_modules=['q_proj','v_proj'], task_type=TaskType.SEQ_CLS)\n"
+     "  model = get_peft_model(base_model, cfg)\n"
+     "  model.print_trainable_parameters()   # sanity: only adapters train\n"
+     "  ... train ... ; model.save_pretrained('adapter')\n"
+     "Reload: PeftModel.from_pretrained(base, 'adapter'). target_modules names differ\n"
+     "per architecture — inspect model.named_modules() to find the linear layers."),
+
+    ("Prepare / organize / split a dataset",
+     ["data", "dataset", "prep", "prepare", "organize", "split", "train", "val",
+      "test", "normalize", "preprocess", "balance", "stratify", "label", "clean"],
+     "  from sklearn.model_selection import train_test_split\n"
+     "  Xtr,Xtmp,ytr,ytmp = train_test_split(X,y,test_size=0.3,stratify=y,random_state=0)\n"
+     "  Xval,Xte,yval,yte = train_test_split(Xtmp,ytmp,test_size=0.5,stratify=ytmp,random_state=0)\n"
+     "Normalize features on TRAIN ONLY, then apply to val/test (no leakage):\n"
+     "  from sklearn.preprocessing import StandardScaler\n"
+     "  sc=StandardScaler().fit(Xtr); Xtr=sc.transform(Xtr); Xte=sc.transform(Xte)\n"
+     "Images: resize + ToTensor + Normalize(mean,std). Keep a fixed split (seed) and\n"
+     "check class balance (np.bincount(y)). Never fit scalers/encoders on test data."),
+
+    ("Read/write HDF5 (.h5) and convert to/from JSON",
+     ["h5", "hdf5", "h5py", "json", "convert", "dataset", "array", "save", "load",
+      "file", "format", "serialize"],
+     "  import h5py, numpy as np, json\n"
+     "  with h5py.File('data.h5','r') as f:\n"
+     "    print(list(f.keys())); arr = f['images'][:]; labels = f['labels'][:]\n"
+     "    attrs = dict(f['images'].attrs)   # metadata\n"
+     "  with h5py.File('out.h5','w') as f:\n"
+     "    f.create_dataset('images', data=arr, compression='gzip')\n"
+     "H5<->JSON: arrays aren't JSON-native — use arr.tolist() to dump, np.array to\n"
+     "reload. json.dump({'shape':list(arr.shape),'data':arr.tolist()}, open('x.json','w')).\n"
+     "For big arrays keep them in H5 and put only metadata/paths in JSON."),
+
+    ("Implement a Transformer block / ViT",
+     ["transformer", "attention", "vit", "vision", "encoder", "block", "self-attention",
+      "multihead", "patch", "embedding", "positional", "layernorm"],
+     "Transformer encoder block (pre-norm):\n"
+     "  attn = nn.MultiheadAttention(d, heads, batch_first=True)\n"
+     "  x = x + attn(ln1(x), ln1(x), ln1(x))[0]      # residual\n"
+     "  x = x + mlp(ln2(x))   # mlp: Linear(d,4d)->GELU->Linear(4d,d)\n"
+     "ViT: split image into patches (Conv2d(kernel=stride=patch) -> flatten), prepend a\n"
+     "learnable [CLS] token, ADD positional embeddings, run N encoder blocks, classify\n"
+     "from the CLS token. Shapes: (B,C,H,W)->(B, num_patches+1, d). Verify a forward\n"
+     "pass runs and output is (B, num_classes); check grads flow (loss.backward())."),
+
+    ("Diagnose a broken PyTorch training run",
+     ["debug", "diagnose", "nan", "loss", "not", "learning", "overfit", "underfit",
+      "shape", "mismatch", "error", "troubleshoot", "fix", "exploding", "gradient"],
+     "- Loss is NaN/Inf: LR too high (lower it), log/sqrt of <=0, divide-by-zero, or\n"
+     "  unnormalized inputs. Add torch.autograd.set_detect_anomaly(True); clip grads\n"
+     "  (nn.utils.clip_grad_norm_); check for NaN in the data.\n"
+     "- Loss flat / not learning: forgot opt.zero_grad or opt.step; LR too low; wrong\n"
+     "  loss (softmax before CrossEntropyLoss); labels/logits misaligned; model not in\n"
+     "  train(); frozen params. Print loss each step + a param's grad norm.\n"
+     "- Shape mismatch: print .shape at each layer; CrossEntropyLoss wants logits\n"
+     "  (N,C) + targets (N,) Long. - Train acc high, val low: overfitting -> augment/\n"
+     "  regularize/early-stop. Always overfit a tiny batch first as a sanity check."),
+
+    ("Generate a LaTeX report / results table",
+     ["latex", "report", "table", "pdf", "document", "tex", "pdflatex", "figure",
+      "results", "write", "tabular", "booktabs"],
+     "Emit a compilable .tex, then build it:\n"
+     "  \\documentclass{article}\\usepackage{booktabs,graphicx}\\begin{document}\n"
+     "  \\begin{tabular}{lr}\\toprule Metric & Value\\\\\\midrule\n"
+     "  Accuracy & 0.94\\\\ F1 & 0.92\\\\\\bottomrule\\end{tabular}\n"
+     "  \\includegraphics[width=.6\\linewidth]{roc.png}\\end{document}\n"
+     "Build: pdflatex -interaction=nonstopmode report.tex  (run twice for refs).\n"
+     "Escape %, _, &, # in text. pandas: df.to_latex('t.tex', index=False). Confirm\n"
+     "report.pdf exists and pdflatex exit code is 0."),
 ]
 
 _WORD = re.compile(r"[a-z0-9.]+")

drydock_cli-3.0.118/drydock/suggest.py

@@ -0,0 +1,30 @@
+"""Recommended next command — a single dimmed hint shown after each turn (à la
+Claude Code's ghost suggestion). Pure logic so it's testable; the TUI renders it.
+"""
+from __future__ import annotations
+
+
+def suggest_next_command(
+    *,
+    ctx_pct: int,
+    wrote_files: bool,
+    ran_bash: bool,
+    had_error: bool,
+    in_git: bool,
+    plan_remaining: bool,
+) -> str | None:
+    """The single most useful next step given what the last turn did, or None to
+    show nothing (better no hint than a noisy one). Order = priority."""
+    if ctx_pct >= 78:
+        return "/compact"          # context nearly full — shrink it before continuing
+    if had_error:
+        return "fix the error above"
+    if plan_remaining:
+        return "continue"          # the model left plan steps unfinished
+    if wrote_files and in_git:
+        return "git diff"          # review what changed
+    if wrote_files:
+        return "run the tests"
+    if ran_bash:
+        return None                # ran a command but nothing else obvious — no clutter
+    return None

{drydock_cli-3.0.116 → drydock_cli-3.0.118}/drydock/tui/app.py

@@ -111,6 +111,8 @@ class DrydockApp(App):
         height: auto; margin: 0 2 1 2; padding: 0 1; color: #d7e6ee;
         border-left: thick #c9a227; background: #14241c;
     }
+    /* Dimmed recommended-next-command hint (empty → 0 lines). */
+    #suggest { height: auto; margin: 0 3; color: #4a6b78; text-style: italic; }
     /* One bottom-docked footer holds, top→bottom: working-line, prompt, status. */
     #footer { dock: bottom; height: auto; background: #0b1f2a; }
     #prompt {
@@ -140,6 +142,7 @@ class DrydockApp(App):
         # does the same. priority so it isn't swallowed by the focused prompt.
         Binding("escape", "stop", "Stop the running turn", priority=True),
         Binding("ctrl+o", "toggle_tools", "Expand/collapse details"),
+        Binding("ctrl+n", "use_suggestion", "Use suggested next command", show=False),
         # Scroll the transcript from the keyboard (focus stays on the prompt,
         # and SSH sessions often don't forward the mouse wheel). priority=True
         # so the prompt's TextArea doesn't swallow PageUp/PageDown first.
@@ -250,6 +253,13 @@ class DrydockApp(App):
         self._skills = load_skills(config.get("cwd") or ".")
         self._current_assistant: AssistantMessage | None = None
         self._last_card: ToolCard | None = None
+        # Recommended-next-command hint state.
+        self._turn_tools: set[str] = set()   # tool names used this turn
+        self._turn_error = False
+        self._plan_remaining = False
+        self._suggestion = ""
+        import os
+        self._in_git = os.path.isdir(os.path.join(config.get("cwd") or ".", ".git"))
         self._busy = False
         # STOP signal: Escape / "/stop" sets it; the agent loop checks it at safe
         # points and ends the turn cleanly (session preserved). Lives in config
@@ -300,6 +310,7 @@ class DrydockApp(App):
         with Vertical(id="footer"):
             yield Static("", id="todo")     # pinned task checklist (empty = hidden)
             yield Static("", id="working")  # in-line activity (empty when idle)
+            yield Static("", id="suggest")  # dimmed recommended-next-command hint
             yield PromptArea(id="prompt")
             yield Static(self._status_text(), id="status")
 
@@ -446,6 +457,9 @@ class DrydockApp(App):
         # turn. If this turn emits its own todo, _render_todo repopulates it.
         self.config.pop("_todo", None)
         self.query_one("#todo", Static).update("")
+        self._turn_tools = set()
+        self._turn_error = False
+        self.query_one("#suggest", Static).update("")  # hide the hint while working
         self._busy = True
         self._work_start = time.monotonic()
         self._last_progress = self._work_start
@@ -1210,6 +1224,7 @@ class DrydockApp(App):
 
     def on_agent_tool_start(self, m: AgentToolStart) -> None:
         self._current_assistant = None  # end the current text block
+        self._turn_tools.add(m.name)
         if m.name == "todo":
             self._render_todo(m.inputs.get("tasks", ""))
             self._last_card = None  # tool_end is a no-op for the checklist
@@ -1229,6 +1244,7 @@ class DrydockApp(App):
 
         items = parse_todo(tasks)
         panel = self.query_one("#todo", Static)
+        self._plan_remaining = any(s != "done" for _, s in items)
         if not items:
             panel.update("")  # collapses to 0 height
             return
@@ -1269,9 +1285,38 @@ class DrydockApp(App):
             return
         self._repeat = None
         self._refresh_status()
+        self._update_suggestion()
         self.query_one("#prompt", PromptArea).focus()
 
+    def _update_suggestion(self) -> None:
+        """Compute + render the dimmed recommended-next-command hint (Claude-Code-
+        style). Empty when nothing useful to suggest."""
+        from drydock.suggest import suggest_next_command
+        limit = self.config.get("context_limit", 65536) or 65536
+        pct = min(100, round(self._ctx_tokens / limit * 100)) if limit else 0
+        wrote = bool(self._turn_tools & {"Write", "Edit"})
+        ran = "Bash" in self._turn_tools
+        self._suggestion = suggest_next_command(
+            ctx_pct=pct, wrote_files=wrote, ran_bash=ran, had_error=self._turn_error,
+            in_git=self._in_git, plan_remaining=self._plan_remaining,
+        ) or ""
+        hint = self.query_one("#suggest", Static)
+        if self._suggestion:
+            from rich.markup import escape
+            hint.update(f"→ next: {escape(self._suggestion)}   [dim](ctrl+n to use)[/]")
+        else:
+            hint.update("")
+
+    def action_use_suggestion(self) -> None:
+        """Accept the recommended next command — drop it into the prompt to edit/send."""
+        if self._suggestion and not self._busy:
+            prompt = self.query_one("#prompt", PromptArea)
+            prompt.text = self._suggestion
+            prompt.move_cursor(prompt.document.end)
+            prompt.focus()
+
     def on_agent_error(self, m: AgentError) -> None:
+        self._turn_error = True
         self._mount(ErrorMessage(m.error))
 
 

{drydock_cli-3.0.116 → drydock_cli-3.0.118/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.116
+Version: 3.0.118
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0

{drydock_cli-3.0.116 → drydock_cli-3.0.118}/drydock_cli.egg-info/SOURCES.txt

@@ -25,6 +25,7 @@ drydock/rmf.py
 drydock/rmf_graph.py
 drydock/skills.py
 drydock/stig.py
+drydock/suggest.py
 drydock/tool_registry.py
 drydock/tuning.py
 drydock/web.py
@@ -108,6 +109,7 @@ tests/test_stig.py
 tests/test_stop.py
 tests/test_streaming_newlines.py
 tests/test_subagent.py
+tests/test_suggest.py
 tests/test_system_prompt_help.py
 tests/test_todo.py
 tests/test_tool_arg_coercion.py

{drydock_cli-3.0.116 → drydock_cli-3.0.118}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 # PyPI distribution name is drydock-cli (the established install name, continued
 # from the retired v2 fork); the import package + CLI command stay `drydock`.
 name = "drydock-cli"
-version = "3.0.116"
+version = "3.0.118"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.11"

drydock_cli-3.0.118/tests/test_suggest.py

@@ -0,0 +1,20 @@
+"""Recommended-next-command suggestion logic (priority-ordered, None when noisy)."""
+from drydock.suggest import suggest_next_command as s
+
+
+def test_priority_and_cases():
+    base = dict(ctx_pct=10, wrote_files=False, ran_bash=False, had_error=False,
+                in_git=False, plan_remaining=False)
+    assert s(**{**base, "ctx_pct": 80}) == "/compact"          # ctx wins
+    assert s(**{**base, "ctx_pct": 80, "had_error": True}) == "/compact"
+    assert s(**{**base, "had_error": True}) == "fix the error above"
+    assert s(**{**base, "plan_remaining": True}) == "continue"
+    assert s(**{**base, "wrote_files": True, "in_git": True}) == "git diff"
+    assert s(**{**base, "wrote_files": True}) == "run the tests"
+    assert s(**{**base, "ran_bash": True}) is None             # no clutter
+    assert s(**base) is None
+
+
+def test_error_beats_plan_and_writes():
+    assert s(ctx_pct=10, wrote_files=True, ran_bash=True, had_error=True,
+             in_git=True, plan_remaining=True) == "fix the error above"