#!/usr/bin/env python3
"""
Bash instruction-tuning dataset generator.

Design:
  * bash_dataset.jsonl is GROUND TRUTH. progress.json is a derived snapshot
    recomputed from the jsonl on every load -> resume is drift-proof.
  * Recipe engine: each recipe family emits (nl, bash) with randomized phrasing
    + concrete params from shared pools. Quotas + per-utility cap + dedup +
    `bash -n` syntax check are all enforced here.
  * Output is appended after every batch; nothing is held in memory to the end.

CLI:
  python generate.py status          # report where we stand
  python generate.py plan            # quota table + what's short
  python generate.py run [--batch N] [--batches K] [--target T]
  python generate.py validate-all    # re-run bash -n over the whole file
"""
import json, os, sys, random, hashlib, subprocess, argparse, tempfile, shutil
import re, io, glob, zipfile, secrets, urllib.request
from argcheck import arg_mismatch

HERE = os.path.dirname(os.path.abspath(__file__))
OUT   = os.path.join(HERE, "bash_dataset.jsonl")
PROG  = os.path.join(HERE, "progress.json")
VALID_DIR = os.path.join(HERE, "._valid")

BASH = shutil.which("bash") or r"C:\Users\User\AppData\Local\Programs\Git\usr\bin\bash.exe"

TARGET_TOTAL = 55000
CAT_SHARE = {"single": 0.40, "pipeline": 0.35, "script": 0.25}
CAT_TARGET = {c: int(round(TARGET_TOTAL * s)) for c, s in CAT_SHARE.items()}
UTIL_CAP = int(TARGET_TOTAL * 0.04)   # 2200: cap on BASE requests per utility (canonical answers <= 4% of rows)
ROW_CAP_PCT = 0.06                    # ceiling on TOTAL rows per utility (base+variants); CLI-overridable
ROW_CAP  = int(TARGET_TOTAL * ROW_CAP_PCT)
_BASE_TARGET = TARGET_TOTAL           # reference for scaling floors on small samples

# v2 knobs (CLI-overridable). SEED_FRAC: share of non-floor requests drawn from
# real seed corpora (tldr/nl2bash) instead of templates. VARIANT_FRAC: share of
# requests that also get 1-2 extra equivalent-answer rows sharing a variant_group.
SEED_FRAC = 0.40
VARIANT_FRAC = 0.30
SEEDS_DIR = os.path.join(HERE, "seeds")
SEEDS = {"single": [], "pipeline": [], "script": []}   # populated by load_seeds() for `run`
SEED_TEMPLATE_CAP = 8      # max times one tldr template may be reused (keeps NL variety); CLI-overridable
_SEED_USE = {}             # per-run template-use counter (keyed by id(template))

# Equivalent system prompts; one is chosen per row so the model doesn't overfit
# to a single exact string. Each entry's "final form" is a chat messages array.
SYSTEM_PROMPTS = [
    "You are a Bash expert.",
    "You are a helpful assistant that writes correct, idiomatic Bash commands.",
    "You are a Linux shell expert. Respond with Bash only.",
    "You translate natural-language requests into correct Bash commands.",
    "You are a command-line assistant specializing in Bash and GNU coreutils.",
]

# Guaranteed minimum count per utility for the info/system commands that small
# models tend to fumble. Floors are filled preferentially before normal quota
# filling. Values reflect how much genuine, non-templated variety each command
# actually supports (uptime/hostname have small command spaces).
MIN_UTIL = {
    "vmstat": 150, "pstree": 150, "nice": 150, "netstat": 150, "renice": 150,
    "lsof": 150, "journalctl": 140, "ss": 120, "w": 100, "iostat": 90,
    "dmesg": 70, "free": 55, "uptime": 28, "hostname": 24,
}
_BASE_MIN_UTIL = dict(MIN_UTIL)   # floors are scaled from this for small --target samples

# --------------------------------------------------------------------------
# shared pools
# --------------------------------------------------------------------------
# pools are generated from realistic stems so combinatorial capacity is large
# while every token stays plausible (real-looking filenames, dirs, hosts, ...).
_STEMS = ["report","data","server","access","error","backup","config","users",
          "results","dump","metrics","debug","auth","build","test","output","export",
          "invoice","order","customer","product","sales","event","audit","session",
          "request","response","payload","summary","archive","index","catalog",
          "inventory","transaction","payment","account","profile","notes","changelog",
          "release","migration","schema","credentials","settings","manifest"]
_TEXT_EXT = ["txt","csv","md","json","log","tsv","yaml","conf","ini"]
_ANY_EXT  = ["txt","log","csv","json","md","py","sh","tmp","bak","conf","yaml","xml",
             "html","css","js","jpg","png","pdf","gz","old","sql","tar.gz","zip"]
_LOG_STEMS = ["server","access","error","output","metrics","debug","auth","build",
              "app","nginx-access","nginx-error","syslog","kern","cron","mail","gc",
              "worker","api","gateway","scheduler","ingest","request","audit"]

def _mk(stems, exts):
    return sorted({f"{s}.{e}" for s in stems for e in exts})

FILES     = _mk(_STEMS, _ANY_EXT)                       # ~1000
LOGFILES  = sorted({f"{s}.log" for s in _LOG_STEMS} | {"syslog","messages","dmesg.log"})
TEXTFILES = _mk(_STEMS, _TEXT_EXT)                      # ~400
CSVFILES  = _mk(["data","inventory","sales","orders","users","products","export",
                 "customers","transactions","metrics","report"], ["csv","tsv"])
DIRNAMES  = ["src","logs","backup","data","tmp","project","dist","build","config",
             "assets","docs","reports","uploads","cache","public","scripts","vendor",
             "images","media","bin","lib","tests","include","static","templates",
             "migrations","fixtures","downloads","releases","artifacts","modules"]
ABSDIRS   = ["/var/log","/etc/nginx","/opt/app","/srv/www","/home/deploy","/var/www",
             "/usr/local/bin","/etc/apache2","/var/lib/mysql","/mnt/data","/srv/data",
             "/home/alice","/var/cache","/opt/scripts","/data/uploads"]
DIRS  = DIRNAMES + ABSDIRS
SDIRS = DIRNAMES
PATTERNS = ["ERROR","WARNING","TODO","FIXME","404","500","403","502","failed",
            "timeout","null","DEBUG","exception","warning:","deprecated",
            "Connection refused","OutOfMemory","segfault","permission denied","fatal",
            "panic","retry","unauthorized","not found","disk full","refused","denied",
            "SIGTERM","traceback","rejected","dropped","throttled","expired","invalid",
            "critical","unreachable","corrupt","stale","overflow"]
WORDS = ["localhost","admin","root","password","GET","POST","PUT","DELETE","session",
         "cookie","token","user_id","email","https","http","cron","kernel","staging",
         "production","enabled","disabled","true","false","warning","info","debug",
         "127.0.0.1","0.0.0.0","success","pending","active","inactive"]
EXTS = ["txt","log","csv","json","md","py","sh","tmp","bak","conf","yaml","xml",
        "html","css","js","jpg","png","gif","pdf","gz","old","sql","zip","cache"]
USERS = ["deploy","www-data","alice","bob","postgres","nginx","jenkins","ubuntu",
         "carol","git","backup","dave","erin","mysql","redis","ec2-user","admin",
         "svc-app","operator","tomcat"]
GROUPS = ["www-data","developers","staff","docker","sudo","admin","deploy","users",
          "wheel","operators","mysql","backup"]
PROCS = ["nginx","node","python","python3","java","mysqld","postgres","redis-server",
         "sshd","apache2","dockerd","gunicorn","celery","php-fpm","containerd","mongod",
         "rabbitmq","elasticsearch","memcached","haproxy","cron","systemd","chrome",
         "vim","tmux"]
SERVICES = ["nginx","docker","ssh","sshd","postgresql","mysql","mariadb","redis",
            "cron","apache2","firewalld","fail2ban","prometheus","grafana-server",
            "elasticsearch","rabbitmq","memcached","haproxy","containerd","chronyd",
            "systemd-networkd","mongod"]
PORTS = [22,80,443,3306,5432,6379,8080,8000,3000,5000,9090,25,53,9200,27017,11211,
         5672,15672,9000,8443,25565,2379]
PKGS = ["nginx","htop","git","curl","vim","docker.io","python3-pip","tmux","jq",
        "tree","ncdu","net-tools","build-essential","unzip","ripgrep","wget","nmap",
        "tcpdump","sysstat","iotop","strace","rsync","zip","postgresql-client",
        "redis-tools","fzf","bat","fd-find","htop"]
_SUB = ["api","www","db01","db02","cache","registry","cdn","mail","git","app01",
        "web01","proxy","auth","staging","monitor","backup"]
_DOM = ["example.com","example.org","internal","local","corp.net","service.io"]
HOSTS = sorted({f"{s}.{d}" for s in _SUB for d in _DOM}
               | {"192.168.1.10","10.0.0.5","172.16.0.20","8.8.8.8","1.1.1.1",
                  "github.com","github.io","localhost"})
COUNTS = [3,5,10,15,20,25,30,40,50,100,200,500,1000]
DAYS = [1,2,3,5,7,10,14,21,30,60,90,180]
SIZES = ["100M","500M","1G","10k","100k","50M","250M","2G","500k","1M","5M","20M"]  # bare magnitudes; find -size sign is set per request direction
BRANCHES = ["main","develop","feature/login","feature/search","release/1.2",
            "release/2.0","hotfix/crash","hotfix/security","staging","bugfix/auth"]

def R(seq): return random.choice(seq)
def pick(*variants): return random.choice(variants)

# --------------------------------------------------------------------------
# recipe registry
# --------------------------------------------------------------------------
RECIPES = []   # {"fn":..., "category":..., "utility":..., "weight":...}
# High-capacity families are weighted up so recipe selection concentrates on
# them instead of wasting attempts colliding on saturated tiny recipes.
HIGHCAP = {
    # pipeline
    "p_freqtop","p_catpipe","p_procpipe","p_netpipe","p_logscan","p_diskpipe",
    "p_find_xargs","p_grep_count","p_awk_pipe","p_curl","p_chain","p_cmdsub",
    "p_redir","p_du_sort","p_ls","p_sed",
    # single
    "r_grep","r_find","r_sed","r_awk","r_curl","r_journalctl","r_systemctl",
    "r_chmod","r_chown","r_cp","r_mv","r_tar","r_fileq","r_ls","r_git_misc",
    # script
    "s_fileproc","s_backup2","s_retry2","s_findclean2","s_getopts2","s_parallel",
    "s_envcheck","s_dbdump","s_hosts_iter","s_funcs2",
    "s_for_big","s_while_big","s_if_big","s_case_big","s_func_big","s_report_big",
    # info/system utilities (high-capacity idiomatic families)
    "r_vmstat2","r_iostat2","r_free2","r_uptime2","r_w2","r_hostname2",
    "r_pstree2","r_dmesg2","r_netstat2","r_nice2","r_lsof","r_ss",
}
def recipe(category, utility):
    def deco(fn):
        RECIPES.append({"fn": fn, "category": category, "utility": utility,
                        "weight": 12 if fn.__name__ in HIGHCAP else 1})
        return fn
    return deco

def L(*lines):
    """join script lines with real newlines"""
    return "\n".join(lines)

import re as _re
# De-concentrate the dominant "Write a script that ..." opening: every such
# request is remapped to one of several equivalents (the relative clause is
# reused verbatim, so grammar stays correct). Cuts the single-prefix share ~7x.
_SCRIPT_LEADS = [
    "Write a script that {c}.",
    "Write a Bash script that {c}.",
    "Write a shell script that {c}.",
    "Create a script that {c}.",
    "I need a script that {c}.",
    "Write me a script that {c}.",
    "Can you write a script that {c}?",
    "Write a small script that {c}.",
]
_SW = _re.compile(r'^write a script that (.+?)\.?$', _re.IGNORECASE)
def diversify_nl(nl):
    m = _SW.match(nl)
    if not m:
        return nl
    clause = m.group(1)
    lead = random.choice(_SCRIPT_LEADS)
    return lead.format(c=clause, C=clause[0].upper()+clause[1:])

# ==========================================================================
# SINGLE-COMMAND RECIPES
# ==========================================================================
@recipe("single","ls")
def r_ls():
    d = R(DIRS)
    return pick(
        (f"List all files in {d}, including hidden ones, in long format.", f"ls -la {d}"),
        (f"Show the contents of the {d} directory sorted by modification time, newest first.", f"ls -lt {d}"),
        (f"How do I list files in {d} sorted by size?", f"ls -lS {d}"),
        (f"give me a human-readable long listing of {d}", f"ls -lh {d}"),
        (f"List only directories inside {d}.", f"ls -d {d}/*/"),
        (f"Show a recursive listing of {d}.", f"ls -R {d}"),
    )

@recipe("single","cp")
def r_cp():
    a,b = R(FILES), R(SDIRS)
    return pick(
        (f"Copy {a} into the {b} directory.", f"cp {a} {b}/"),
        (f"Make a backup copy of {a} called {a}.bak", f"cp {a} {a}.bak"),
        (f"copy the whole {b} folder to {b}_copy recursively", f"cp -r {b} {b}_copy"),
        (f"Copy {a} to {b}/ but keep the original timestamps and permissions.", f"cp -p {a} {b}/"),
        (f"Copy {a} into {b} only if it's newer than what's there.", f"cp -u {a} {b}/"),
    )

@recipe("single","mv")
def r_mv():
    a = R(FILES); d = R(SDIRS); e = R(EXTS)
    return pick(
        (f"Rename {a} to {a}.old", f"mv {a} {a}.old"),
        (f"Move {a} into the {d} folder.", f"mv {a} {d}/"),
        (f"move all .{e} files into the {d} directory", f"mv *.{e} {d}/"),
        (f"Rename {a} to {a}.old without overwriting if the target already exists.", f"mv -n {a} {a}.old"),
    )

@recipe("single","rm")
def r_rm():
    d = R(SDIRS); f = R(FILES)
    return pick(
        (f"Delete all .tmp files in the current directory (prompt before each removal to be safe).", "rm -i *.tmp"),
        (f"Remove the empty directory {d}.", f"rmdir {d}"),
        (f"Force-remove the {d} directory and everything in it. (Careful: this is destructive and cannot be undone.)", f"rm -rf {d}"),
        (f"Delete {f} but ask for confirmation first.", f"rm -i {f}"),
    )

@recipe("single","mkdir")
def r_mkdir():
    d = R(SDIRS)
    return pick(
        (f"Create a directory called {d}.", f"mkdir {d}"),
        (f"Make the nested directory {d}/2026/logs, creating parents as needed.", f"mkdir -p {d}/2026/logs"),
        (f"create three folders at once: src, tests and docs", "mkdir src tests docs"),
        (f"Make a directory {d} with permissions 700.", f"mkdir -m 700 {d}"),
    )

@recipe("single","touch")
def r_touch():
    f = R(FILES); g = R(FILES)
    return pick(
        (f"Create an empty file named {f}.", f"touch {f}"),
        (f"Update the modification time of {g} to now.", f"touch {g}"),
        (f"create empty files log1.txt log2.txt log3.txt in one go", "touch log{1..3}.txt"),
    )

@recipe("single","cat")
def r_cat():
    f = R(TEXTFILES)
    return pick(
        (f"Print the contents of {f} to the terminal.", f"cat {f}"),
        (f"Show {f} with line numbers.", f"cat -n {f}"),
        (f"Concatenate part1.txt and part2.txt into whole.txt", "cat part1.txt part2.txt > whole.txt"),
        (f"display {f} showing tabs and line endings", f"cat -A {f}"),
    )

@recipe("single","head")
def r_head():
    f,n = R(LOGFILES), R(COUNTS)
    return pick(
        (f"Show the first {n} lines of {f}.", f"head -n {n} {f}"),
        (f"what are the top {n} lines in {f}?", f"head -n {n} {f}"),
        (f"Print everything in {f} except the last {n} lines.", f"head -n -{n} {f}"),
    )

@recipe("single","tail")
def r_tail():
    f,n = R(LOGFILES), R(COUNTS)
    return pick(
        (f"Show the last {n} lines of {f}.", f"tail -n {n} {f}"),
        (f"Follow {f} live as new lines are appended.", f"tail -f {f}"),
        (f"keep watching {f} for new entries and start from the last {n} lines", f"tail -n {n} -f {f}"),
        (f"Print {f} starting from line {n} to the end.", f"tail -n +{n} {f}"),
    )

@recipe("single","chmod")
def r_chmod():
    f = R(["deploy.sh","main.py","backup.sh","run.sh"]+FILES); cd = R(SDIRS)
    return pick(
        (f"Make {f} executable.", f"chmod +x {f}"),
        (f"Set {f} to permissions 644.", f"chmod 644 {f}"),
        (f"Recursively make everything in {cd} readable and writable by the owner only.", f"chmod -R 600 {cd}"),
        (f"give the owner rwx and everyone else read on {f}", f"chmod 744 {f}"),
        (f"Remove write permission for group and others on {f}.", f"chmod go-w {f}"),
    )

@recipe("single","chown")
def r_chown():
    f = R(FILES); u = R(USERS); g = R(GROUPS); d = R(SDIRS)
    return pick(
        (f"Change the owner of {f} to {u}.", f"sudo chown {u} {f}"),
        (f"Recursively set owner and group of {d} to {u}:{g}.", f"sudo chown -R {u}:{g} {d}"),
        (f"change just the group of {f} to {g}", f"sudo chgrp {g} {f}"),
    )

@recipe("single","find")
def r_find():
    d = R(DIRS); e = R(EXTS); sz = R(SIZES); dd = R(DAYS); sub = R(SDIRS); u = R(USERS)
    return pick(
        (f"Find all .{e} files under {d}.", f"find {d} -type f -name '*.{e}'"),
        (f"Find files in {d} larger than {sz}.", f"find {d} -type f -size +{sz}"),
        (f"Find files in {d} smaller than {sz}.", f"find {d} -type f -size -{sz}"),
        (f"locate files under {d} modified in the last {dd} days", f"find {d} -type f -mtime -{dd}"),
        (f"Find empty files in {d}.", f"find {d} -type f -empty"),
        (f"Find directories named {sub} anywhere under {d}.", f"find {d} -type d -name '{sub}'"),
        (f"Find files in {d} owned by {u}.", f"find {d} -type f -user {u}"),
    )

@recipe("single","grep")
def r_grep():
    p,f = R(PATTERNS), R(LOGFILES); d = R(DIRS)
    return pick(
        (f"Search {f} for lines containing '{p}'.", f"grep '{p}' {f}"),
        (f"Case-insensitively find '{p}' in {f}.", f"grep -i '{p}' {f}"),
        (f"Count how many lines in {f} match '{p}'.", f"grep -c '{p}' {f}"),
        (f"recursively search {d} for '{p}' and show line numbers", f"grep -rn '{p}' {d}"),
        (f"Show lines in {f} that do NOT contain '{p}'.", f"grep -v '{p}' {f}"),
        (f"Find '{p}' in {f} plus 3 lines of context around each match.", f"grep -C 3 '{p}' {f}"),
        (f"List just the filenames under {d} that contain '{p}'.", f"grep -rl '{p}' {d}"),
    )

@recipe("single","sed")
def r_sed():
    f = R(TEXTFILES)
    a,b = R(WORDS), R(WORDS)
    return pick(
        (f"Replace every occurrence of '{a}' with '{b}' in {f} and print the result.", f"sed 's/{a}/{b}/g' {f}"),
        (f"Edit {f} in place, replacing '{a}' with '{b}'.", f"sed -i 's/{a}/{b}/g' {f}"),
        (f"delete all blank lines from {f}", f"sed '/^$/d' {f}"),
        (f"Print only lines 10 through 20 of {f}.", f"sed -n '10,20p' {f}"),
        (f"Delete the first line of {f} in place.", f"sed -i '1d' {f}"),
    )

@recipe("single","awk")
def r_awk():
    f = R(["data.csv","inventory.csv","access.log","metrics.log"])
    col = R([1,2,3,4])
    return pick(
        (f"Print the {col}nd column of {f} (whitespace separated).", f"awk '{{print ${col}}}' {f}"),
        (f"Print column {col} of the comma-separated file {f}.", f"awk -F, '{{print ${col}}}' {f}"),
        (f"Sum up the values in column {col} of {f}.", f"awk '{{sum+=${col}}} END{{print sum}}' {f}"),
        (f"print lines of {f} where column {col} is greater than 100", f"awk '${col} > 100' {f}"),
        (f"Print the number of fields on each line of {f}.", f"awk '{{print NF}}' {f}"),
    )

@recipe("single","sort")
def r_sort():
    f = R(TEXTFILES)
    return pick(
        (f"Sort {f} alphabetically.", f"sort {f}"),
        (f"Sort {f} numerically in reverse order.", f"sort -nr {f}"),
        (f"Sort {f} and remove duplicate lines.", f"sort -u {f}"),
        (f"sort {f} by the 2nd column numerically", f"sort -k2 -n {f}"),
    )

@recipe("single","uniq")
def r_uniq():
    f = R(TEXTFILES)
    return pick(
        (f"Remove adjacent duplicate lines from the already-sorted {f}.", f"uniq {f}"),
        (f"Count occurrences of each unique line in {f} (assume it's sorted).", f"uniq -c {f}"),
        (f"show only the lines in {f} that appear more than once", f"uniq -d {f}"),
    )

@recipe("single","wc")
def r_wc():
    f = R(FILES)
    return pick(
        (f"Count the number of lines in {f}.", f"wc -l {f}"),
        (f"How many words are in {f}?", f"wc -w {f}"),
        (f"count the bytes in {f}", f"wc -c {f}"),
    )

@recipe("single","cut")
def r_cut():
    f = R(["data.csv","inventory.csv","users.txt","/etc/passwd"])
    return pick(
        (f"Extract the first field of {f} using comma as the delimiter.", f"cut -d, -f1 {f}"),
        (f"Get fields 1 and 3 from {f}, colon separated.", f"cut -d: -f1,3 {f}"),
        (f"cut out the first 10 characters of each line in {f}", f"cut -c1-10 {f}"),
    )

@recipe("single","tr")
def r_tr():
    f = R(TEXTFILES)
    return pick(
        (f"Convert the contents of {f} to uppercase.", f"tr 'a-z' 'A-Z' < {f}"),
        (f"Squeeze repeated spaces into a single space in {f}.", f"tr -s ' ' < {f}"),
        (f"delete all digits from {f}", f"tr -d '0-9' < {f}"),
    )

@recipe("single","ps")
def r_ps():
    psu = R(USERS)
    return pick(
        ("Show all running processes with full details.", "ps aux"),
        ("List processes in a tree/hierarchy format.", "ps -ef --forest"),
        (f"Show all processes for the user {psu}.", f"ps -u {psu}"),
        ("Display the top memory-consuming processes.", "ps aux --sort=-%mem"),
    )

@recipe("single","kill")
def r_kill():
    pid = random.randint(1000,9999)
    return pick(
        (f"Gracefully terminate the process with PID {pid}.", f"kill {pid}"),
        (f"Force-kill process {pid}.", f"kill -9 {pid}"),
        (f"send SIGHUP to process {pid} to make it reload its config", f"kill -HUP {pid}"),
    )

@recipe("single","pkill")
def r_pkill():
    p = R(PROCS); u = R(USERS)
    return pick(
        (f"Kill all {p} processes by name.", f"pkill {p}"),
        (f"Force-kill every process whose name matches {p}.", f"pkill -9 {p}"),
        (f"gracefully stop all processes owned by {u}", f"pkill -u {u}"),
    )

@recipe("single","pgrep")
def r_pgrep():
    p = R(PROCS)
    return pick(
        (f"Find the PIDs of all {p} processes.", f"pgrep {p}"),
        (f"list PIDs and names of processes matching {p}", f"pgrep -a {p}"),
        (f"Get the PID of the newest {p} process.", f"pgrep -n {p}"),
    )

@recipe("single","df")
def r_df():
    return pick(
        ("Show disk space usage of all mounted filesystems in human-readable form.", "df -h"),
        ("How much space is left on the root filesystem?", "df -h /"),
        ("Show filesystem disk usage including inode counts.", "df -i"),
    )

@recipe("single","du")
def r_du():
    d = R(DIRS)
    return pick(
        (f"Show the total size of the {d} directory in human-readable form.", f"du -sh {d}"),
        (f"list the size of each subdirectory in {d}", f"du -h --max-depth=1 {d}"),
        (f"How big is {d} overall?", f"du -sh {d}"),
    )

@recipe("single","free")
def r_free():
    return pick(
        ("Show current memory usage in human-readable units.", "free -h"),
        ("Display memory usage in megabytes.", "free -m"),
        ("show memory including a total line for RAM plus swap", "free -h -t"),
        ("Report memory usage refreshing every 2 seconds.", "free -h -s 2"),
    )

@recipe("single","uptime")
def r_uptime():
    return pick(
        ("How long has the system been running?", "uptime"),
        ("Show just the load averages in a pretty form.", "uptime"),
        ("print uptime in the short 'pretty' format", "uptime -p"),
        ("When did the system last boot?", "uptime -s"),
    )

@recipe("single","uname")
def r_uname():
    return pick(
        ("Print all system information (kernel, hostname, architecture, etc.).", "uname -a"),
        ("What kernel release is this machine running?", "uname -r"),
        ("show the machine hardware architecture", "uname -m"),
    )

@recipe("single","hostname")
def r_hostname():
    return pick(
        ("Show the system's hostname.", "hostname"),
        ("Print all the IP addresses assigned to this host.", "hostname -I"),
        ("what's the fully qualified domain name of this machine?", "hostname -f"),
    )

@recipe("single","vmstat")
def r_vmstat():
    n = R([1,2,3,5])
    c = R([5,10,3])
    return pick(
        (f"Report virtual memory statistics every {n} seconds, {c} times.", f"vmstat {n} {c}"),
        ("Show a one-shot summary of virtual memory, processes and CPU.", "vmstat"),
        (f"monitor system performance with vmstat every {n} seconds using human-readable units", f"vmstat -S M {n}"),
        ("Display active/inactive memory breakdown with vmstat.", "vmstat -a"),
    )

@recipe("single","iostat")
def r_iostat():
    n = R([1,2,5])
    return pick(
        (f"Show CPU and disk I/O statistics every {n} seconds.", f"iostat {n}"),
        ("Display extended disk I/O stats in human-readable form.", "iostat -xh"),
        (f"report I/O stats {n} times, one per second", f"iostat 1 {n}"),
        ("Show only device utilization stats, not CPU.", "iostat -d"),
    )

@recipe("single","pstree")
def r_pstree():
    p = R(PROCS)
    return pick(
        ("Show the process tree with PIDs.", "pstree -p"),
        ("Display the process hierarchy for user deploy.", "pstree deploy"),
        ("show the process tree highlighting the current process and its ancestors", "pstree -hp"),
        (f"visualize the child processes of {p} as a tree", f"pstree -p $(pgrep -o {p})"),
    )

@recipe("single","w")
def r_w():
    return pick(
        ("Show who is logged in and what they are doing.", "w"),
        ("List logged-in users without the header line.", "w -h"),
        ("show logged-in users but hide the command column", "w -s"),
    )

@recipe("single","who")
def r_who():
    return pick(
        ("List all users currently logged in.", "who"),
        ("Who am I logged in as on this terminal?", "whoami"),
        ("show the system boot time using who", "who -b"),
    )

@recipe("single","nice")
def r_nice():
    return pick(
        (f"Start a backup with tar at the lowest CPU priority.", "nice -n 19 tar -czf backup.tar.gz /home/deploy"),
        ("Run a python script with a nice value of 10.", "nice -n 10 python main.py"),
        ("launch a compile job at reduced priority so it doesn't hog the CPU", "nice -n 15 make -j4"),
    )

@recipe("single","renice")
def r_renice():
    pid = random.randint(1000,9999); u = R(USERS)
    return pick(
        (f"Lower the priority of process {pid} to nice value 10.", f"renice -n 10 -p {pid}"),
        (f"Bump process {pid} to a higher priority (nice -5). Requires root.", f"sudo renice -n -5 -p {pid}"),
        (f"reduce the priority of all processes owned by {u}", f"renice -n 15 -u {u}"),
    )

@recipe("single","lsof")
def r_lsof():
    port=R(PORTS); proc=R(PROCS); u=R(USERS); d=R(DIRS); pid=random.randint(500,9000)
    nl,b=_F([
      (f"lsof -i :{port}", (f"Show which process is using port {port}.",
        f"What's bound to port {port}?",f"Find the process listening on port {port}.")),
      (f"lsof -i :{port} -t", (f"Print just the PID using port {port}.",
        f"Get the bare PID that holds port {port}.")),
      (f"lsof -c {proc}", (f"List all files opened by {proc}.",f"Show open files for the {proc} process.")),
      (f"lsof -u {u}", (f"Which files does user {u} have open?",f"List open files owned by {u}.")),
      (f"lsof -p {pid}", (f"List the files opened by process {pid}.",f"Show what PID {pid} has open.")),
      (f"lsof +D {d}", (f"Show every open file under {d}.",f"Which processes have files open in {d}?")),
      ("lsof -i", ("List all open network connections.","Show every network socket in use.")),
      ("lsof -i tcp", ("List all open TCP connections.","Show TCP sockets currently in use.")),
      ("lsof -nP -iTCP -sTCP:LISTEN", ("List listening TCP sockets without resolving names/ports.",
        "Show all TCP listeners numerically via lsof.")),
      (f"lsof -i :{port} -sTCP:ESTABLISHED", (f"Show established connections on port {port}.",
        f"List active (established) sessions on port {port}.")),
    ])
    return nl, b, "lsof"

@recipe("single","ss")
def r_ss():
    port=R(PORTS); h=R(HOSTS)
    nl,b=_F([
      ("ss -tlnp", ("List listening TCP sockets with the owning process.",
        "Show TCP listeners and their PIDs.","What TCP ports are being listened on, and by what?")),
      ("ss -ulnp", ("List listening UDP sockets with their processes.","Show UDP listeners numerically.")),
      ("ss -tulnp", ("List all listening TCP and UDP sockets with programs.",
        "Show every listening socket and the process behind it.")),
      ("ss -t state established", ("Show all established TCP connections.","List active TCP sessions.")),
      ("ss -s", ("Summarize socket statistics by type.","Show a summary of socket counts.")),
      ("ss -tan", ("Show all TCP sockets numerically.","List every TCP socket without name resolution.")),
      (f"ss -tlnp sport = :{port}", (f"Is anything listening on port {port}?",
        f"Show the listener on port {port}.",f"Check what holds port {port} with ss.")),
      (f"ss -tn dst {h}", (f"Show TCP connections to {h}.",f"List sessions with destination {h}.")),
      (f"ss -tn 'sport = :{port} or dport = :{port}'", (f"Show all TCP sockets touching port {port}.",
        f"List connections using port {port} as source or destination.")),
      ("ss -tp state time-wait", ("Show TCP sockets in the TIME-WAIT state with their process.",
        "List connections stuck in TIME-WAIT.")),
    ])
    return nl, b, "ss"

@recipe("single","netstat")
def r_netstat():
    return pick(
        ("List all listening ports and the programs using them.", "netstat -tulpn"),
        ("Show the kernel routing table.", "netstat -rn"),
        ("display network interface statistics", "netstat -i"),
    )

@recipe("single","dmesg")
def r_dmesg():
    return pick(
        ("Show kernel ring buffer messages with human-readable timestamps.", "dmesg -T"),
        ("Follow new kernel messages as they arrive.", "dmesg -w"),
        ("show only kernel error and warning level messages", "dmesg --level=err,warn"),
        ("Display kernel messages colorized with timestamps.", "dmesg -TL"),
    )

@recipe("single","journalctl")
def r_journalctl():
    s = R(SERVICES); dd = R(DAYS)
    return pick(
        (f"Show the systemd journal for the {s} service.", f"journalctl -u {s}"),
        (f"Follow live logs for {s}.", f"journalctl -u {s} -f"),
        ("Show all journal entries since the last boot.", "journalctl -b"),
        (f"show {s} logs from the last {dd} days", f"journalctl -u {s} --since '{dd} days ago'"),
        ("Display kernel messages from the journal with priority error or worse.", "journalctl -k -p err"),
        (f"Show the 50 most recent {s} log lines, newest last.", f"journalctl -u {s} -n 50"),
    )

@recipe("single","systemctl")
def r_systemctl():
    s = R(SERVICES)
    return pick(
        (f"Restart the {s} service.", f"sudo systemctl restart {s}"),
        (f"Check the status of {s}.", f"systemctl status {s}"),
        (f"enable {s} to start on boot", f"sudo systemctl enable {s}"),
        (f"Is the {s} service currently active?", f"systemctl is-active {s}"),
        ("List all failed systemd units.", "systemctl --failed"),
        (f"reload {s} without a full restart", f"sudo systemctl reload {s}"),
    )

@recipe("single","ip")
def r_ip():
    return pick(
        ("Show all network interfaces and their IP addresses.", "ip addr show"),
        ("Display the routing table.", "ip route"),
        ("show statistics for all network links", "ip -s link"),
        ("What's the default gateway?", "ip route | grep default"),
    )

@recipe("single","ping")
def r_ping():
    h = R(HOSTS)
    return pick(
        (f"Ping {h} four times and stop.", f"ping -c 4 {h}"),
        (f"check if {h} is reachable with 3 pings", f"ping -c 3 {h}"),
    )

@recipe("single","curl")
def r_curl():
    h = R(HOSTS)
    return pick(
        (f"Fetch https://{h}/health and print only the HTTP status code.", f"curl -s -o /dev/null -w '%{{http_code}}' https://{h}/health"),
        (f"Download https://{h}/file.zip and save it with its remote name.", f"curl -O https://{h}/file.zip"),
        (f"send a GET request to https://{h}/api and show the response headers", f"curl -I https://{h}/api"),
        (f"POST a JSON body to https://{h}/api/users", f"curl -X POST -H 'Content-Type: application/json' -d '{{\"name\":\"alice\"}}' https://{h}/api/users"),
        (f"follow redirects when fetching https://{h}", f"curl -L https://{h}"),
    )

@recipe("single","wget")
def r_wget():
    h = R(HOSTS)
    return pick(
        (f"Download https://{h}/archive.tar.gz.", f"wget https://{h}/archive.tar.gz"),
        (f"quietly download https://{h}/data.json and save it as data.json", f"wget -q -O data.json https://{h}/data.json"),
        (f"Mirror the site https://{h} recursively.", f"wget -r -np https://{h}"),
        (f"resume an interrupted download of https://{h}/big.iso", f"wget -c https://{h}/big.iso"),
    )

@recipe("single","tar")
def r_tar():
    d = R(SDIRS)
    return pick(
        (f"Create a gzip-compressed archive of the {d} directory.", f"tar -czf {d}.tar.gz {d}"),
        (f"Extract archive.tar.gz into the current directory.", "tar -xzf archive.tar.gz"),
        (f"List the contents of backup.tar.gz without extracting.", "tar -tzf backup.tar.gz"),
        (f"extract backup.tar.gz into the {d} folder", f"tar -xzf backup.tar.gz -C {d}"),
        (f"make a bzip2-compressed tarball of {d}", f"tar -cjf {d}.tar.bz2 {d}"),
    )

@recipe("single","gzip")
def r_gzip():
    f = R(LOGFILES)
    return pick(
        (f"Compress {f} with gzip.", f"gzip {f}"),
        (f"Decompress {f}.gz.", f"gunzip {f}.gz"),
        (f"compress {f} but keep the original file too", f"gzip -k {f}"),
    )

@recipe("single","zip")
def r_zip():
    d = R(SDIRS)
    return pick(
        (f"Zip up the {d} directory into {d}.zip.", f"zip -r {d}.zip {d}"),
        (f"Unzip archive.zip into the current folder.", "unzip archive.zip"),
        (f"list the contents of archive.zip without extracting", "unzip -l archive.zip"),
    )

@recipe("single","ln")
def r_ln():
    f = R(FILES)
    return pick(
        (f"Create a symbolic link named latest.log pointing to {f}.", f"ln -s {f} latest.log"),
        (f"make a symlink to /opt/app/current in your home directory called app", "ln -s /opt/app/current ~/app"),
    )

@recipe("single","stat")
def r_stat():
    f = R(FILES)
    return pick(
        (f"Show detailed metadata for {f}.", f"stat {f}"),
        (f"Print just the octal permission bits of {f}.", f"stat -c '%a' {f}"),
        (f"what's the size of {f} in bytes?", f"stat -c '%s' {f}"),
    )

@recipe("single","file")
def r_file():
    f = R(FILES); d = R(SDIRS)
    return pick(
        (f"Determine the file type of {f}.", f"file {f}"),
        (f"check the type of every file in {d}", f"file {d}/*"),
    )

@recipe("single","date")
def r_date():
    return pick(
        ("Print the current date and time.", "date"),
        ("Show the current date in YYYY-MM-DD format.", "date +%Y-%m-%d"),
        ("get the current Unix timestamp", "date +%s"),
        ("What was the date 7 days ago?", "date -d '7 days ago' +%Y-%m-%d"),
        ("Print the current time in UTC.", "date -u"),
    )

@recipe("single","df_git_status")
def r_git_misc():
    br = R(BRANCHES); br2 = R(BRANCHES)
    return pick(
        ("Show the current git status in short form.", "git status -s"),
        (f"Create and switch to a new branch called {br}.", f"git checkout -b {br}"),
        ("Show the last 5 commits as a one-line log.", "git log --oneline -5"),
        ("Stage all changes and commit with a message.", "git commit -am 'update'"),
        (f"Pull the latest changes for the {br2} branch.", f"git pull origin {br2}"),
        ("Show what changed but hasn't been staged yet.", "git diff"),
        ("Discard all uncommitted changes in the working tree. (Destructive.)", "git checkout -- ."),
        (f"push the current branch and set upstream to origin", "git push -u origin HEAD"),
        ("Show which files changed in the last commit.", "git show --stat HEAD"),
        ("Undo the last commit but keep the changes staged.", "git reset --soft HEAD~1"),
    )
# relabel utility to git
RECIPES[-1]["utility"] = "git"

@recipe("single","apt")
def r_apt():
    p = R(PKGS)
    return pick(
        (f"Install {p} with apt.", f"sudo apt install -y {p}"),
        ("Update the package index and upgrade all packages.", "sudo apt update && sudo apt upgrade -y"),
        (f"Search apt for packages matching {p}.", f"apt search {p}"),
        (f"remove {p} and its config files", f"sudo apt purge -y {p}"),
        (f"show info about the {p} package", f"apt show {p}"),
    )

@recipe("single","dnf")
def r_dnf():
    p = R(PKGS)
    return pick(
        (f"Install {p} using dnf.", f"sudo dnf install -y {p}"),
        ("Update all packages with dnf.", "sudo dnf upgrade -y"),
        (f"remove the {p} package with yum", f"sudo yum remove -y {p}"),
    )

@recipe("single","pacman")
def r_pacman():
    p = R(PKGS)
    return pick(
        (f"Install {p} with pacman.", f"sudo pacman -S {p}"),
        ("Sync and update all packages on Arch.", "sudo pacman -Syu"),
        (f"remove {p} and unneeded dependencies", f"sudo pacman -Rs {p}"),
    )

@recipe("single","ssh")
def r_ssh():
    h,u = R(HOSTS), R(USERS); port = R(PORTS)
    return pick(
        (f"SSH into {h} as {u}.", f"ssh {u}@{h}"),
        (f"connect to {h} on port {port} as {u}", f"ssh -p {port} {u}@{h}"),
        (f"Run 'uptime' on {h} over SSH without an interactive session.", f"ssh {u}@{h} uptime"),
    )

@recipe("single","scp")
def r_scp():
    h,u,f = R(HOSTS), R(USERS), R(FILES); lf = R(LOGFILES)
    return pick(
        (f"Copy {f} to {h}'s /tmp directory as {u}.", f"scp {f} {u}@{h}:/tmp/"),
        (f"download /var/log/{lf} from {h} to the current dir", f"scp {u}@{h}:/var/log/{lf} ."),
    )

@recipe("single","rsync")
def r_rsync():
    a,b = R(SDIRS), R(SDIRS)
    h = R(HOSTS); u = R(USERS)
    return pick(
        (f"Sync the {a} directory to {b} preserving attributes.", f"rsync -av {a}/ {b}/"),
        (f"Mirror {a} to {h}:/backup deleting files that no longer exist locally.", f"rsync -avz --delete {a}/ {u}@{h}:/backup/"),
        (f"do a dry-run rsync of {a} to {b} to see what would change", f"rsync -avn {a}/ {b}/"),
    )

@recipe("single","id")
def r_id():
    u = R(USERS)
    return pick(
        (f"Show the user and group IDs for {u}.", f"id {u}"),
        ("What groups does the current user belong to?", "id -Gn"),
        ("Print the current user's numeric UID.", "id -u"),
    )

@recipe("single","which")
def r_which():
    c = R(["python3","node","git","docker","curl","psql"])
    return pick(
        (f"Where is the {c} binary located?", f"which {c}"),
        (f"find the full path of {c} and follow symlinks", f"readlink -f $(which {c})"),
        (f"Show the type and location of {c}.", f"type -a {c}"),
    )

@recipe("single","mount")
def r_mount():
    return pick(
        ("Show all currently mounted filesystems in a readable table.", "mount | column -t"),
        ("Mount /dev/sdb1 at /mnt/data.", "sudo mount /dev/sdb1 /mnt/data"),
        ("unmount /mnt/data", "sudo umount /mnt/data"),
    )

@recipe("single","top")
def r_top():
    p = R(PROCS)
    return pick(
        ("Run top in batch mode for a single snapshot.", "top -b -n1"),
        ("Launch an interactive process monitor sorted by CPU.", "top"),
        (f"show top output for just the {p} processes", f"top -p $(pgrep -d, {p})"),
    )

@recipe("single","env")
def r_env():
    return pick(
        ("Print all environment variables.", "env"),
        ("Show the value of the PATH environment variable.", "echo $PATH"),
        (f"run a command with a temporary env var APP_ENV set to production", "env APP_ENV=production ./deploy.sh"),
    )

# ==========================================================================
# PIPELINE RECIPES
# ==========================================================================
@recipe("pipeline","grep")
def p_grep_count():
    p,f = R(PATTERNS), R(LOGFILES)
    return pick(
        (f"Count how many unique IP-like first fields appear in {f}.", f"awk '{{print $1}}' {f} | sort | uniq -c | sort -nr"),
        (f"Find the 10 most common '{p}'-related lines in {f}.", f"grep '{p}' {f} | sort | uniq -c | sort -nr | head -n 10"),
        (f"How many lines in {f} mention '{p}'?", f"grep -c '{p}' {f} | cat"),
        (f"list the distinct error messages in {f}", f"grep -i error {f} | sort -u"),
    )
RECIPES[-1]["utility"]="grep"

@recipe("pipeline","ps")
def p_ps_grep():
    p = R(PROCS)
    return pick(
        (f"Find the running {p} processes (excluding the grep itself).", f"ps aux | grep [{p[0]}]{p[1:]}"),
        (f"Show the PID and memory of {p} processes.", f"ps aux | grep {p} | grep -v grep | awk '{{print $2, $4}}'"),
        ("Show the top 5 processes by memory usage.", "ps aux --sort=-%mem | head -n 6"),
        ("List the top 5 CPU-hungry processes.", "ps aux --sort=-%cpu | head -n 6"),
    )
RECIPES[-1]["utility"]="ps"

@recipe("pipeline","du")
def p_du_sort():
    d = R(DIRS)
    return pick(
        (f"Show the 10 largest subdirectories in {d}.", f"du -h {d}/* | sort -rh | head -n 10"),
        (f"Find the biggest files under {d}.", f"du -ah {d} | sort -rh | head -n 20"),
        (f"which directories under {d} are eating the most space?", f"du -h --max-depth=1 {d} | sort -rh"),
    )
RECIPES[-1]["utility"]="du"

@recipe("pipeline","find")
def p_find_xargs():
    d = R(DIRS)
    e = R(EXTS)
    return pick(
        (f"Find all .{e} files under {d} and delete them. (Careful: destructive.)", f"find {d} -type f -name '*.{e}' -print0 | xargs -0 rm -f"),
        (f"Count total lines across all .{e} files in {d}.", f"find {d} -type f -name '*.{e}' -print0 | xargs -0 cat | wc -l"),
        (f"gzip every .log file under {d}", f"find {d} -type f -name '*.log' -print0 | xargs -0 gzip"),
        (f"search all .{e} files under {d} for the word TODO", f"find {d} -name '*.{e}' -print0 | xargs -0 grep -l TODO"),
        (f"change permissions to 644 on all files under {d}", f"find {d} -type f -print0 | xargs -0 chmod 644"),
    )
RECIPES[-1]["utility"]="find"

@recipe("pipeline","cat")
def p_cat_sort():
    f = R(TEXTFILES)
    return pick(
        (f"Show the unique sorted lines of {f}.", f"cat {f} | sort | uniq"),
        (f"Count how many times each line appears in {f}, most frequent first.", f"sort {f} | uniq -c | sort -nr"),
        (f"get the 5 most common words in {f}", f"cat {f} | tr ' ' '\\n' | sort | uniq -c | sort -nr | head -n 5"),
    )
RECIPES[-1]["utility"]="sort"

@recipe("pipeline","awk")
def p_awk_pipe():
    f = R(["access.log","metrics.log","data.csv"])
    return pick(
        (f"Sum the response sizes (column 10) in {f}.", f"awk '{{s+=$10}} END{{print s}}' {f}"),
        (f"Show the average of the second column in {f}.", f"awk '{{s+=$2; n++}} END{{print s/n}}' {f}"),
        (f"count requests per HTTP status code in {f}", f"awk '{{print $9}}' {f} | sort | uniq -c | sort -nr"),
        (f"print the total and count of column 3 in {f}", f"awk '{{sum+=$3; c++}} END{{print sum, c}}' {f}"),
    )
RECIPES[-1]["utility"]="awk"

@recipe("pipeline","journalctl")
def p_journal():
    s = R(SERVICES)
    return pick(
        (f"Count error lines in the {s} journal since yesterday.", f"journalctl -u {s} --since yesterday | grep -ic error"),
        (f"Show the last 20 warning entries for {s}.", f"journalctl -u {s} -p warning -n 20 --no-pager"),
        (f"which {s} log lines mention 'failed'?", f"journalctl -u {s} --no-pager | grep -i failed"),
    )
RECIPES[-1]["utility"]="journalctl"

@recipe("pipeline","ss")
def p_ss():
    port = R(PORTS)
    return pick(
        ("Count how many established TCP connections there are.", "ss -t state established | tail -n +2 | wc -l"),
        (f"How many connections are there to port {port}?", f"ss -tn | grep ':{port}' | wc -l"),
        ("List the remote IPs with the most open connections.", "ss -tn | awk 'NR>1 {print $5}' | cut -d: -f1 | sort | uniq -c | sort -nr | head"),
    )
RECIPES[-1]["utility"]="ss"

@recipe("pipeline","history")
def p_history():
    return pick(
        ("Show the 10 most frequently used commands from your shell history.", "history | awk '{print $2}' | sort | uniq -c | sort -nr | head -n 10"),
        (f"search your command history for anything with 'docker'", "history | grep docker"),
    )
RECIPES[-1]["utility"]="history"

@recipe("pipeline","df")
def p_df_awk():
    return pick(
        ("Print the used percentage of the root filesystem as a number.", "df -h / | awk 'NR==2 {print $5}'"),
        ("Warn if any filesystem is over 90% full.", "df -h | awk 'NR>1 && $5+0 > 90 {print $6, $5}'"),
        ("show mount points sorted by usage percentage", "df -h | awk 'NR>1 {print $5, $6}' | sort -rn"),
    )
RECIPES[-1]["utility"]="df"

@recipe("pipeline","cut")
def p_cut():
    return pick(
        ("List all usernames on the system from /etc/passwd.", "cut -d: -f1 /etc/passwd | sort"),
        (f"extract unique domains from the second field of emails.txt", "cut -d@ -f2 emails.txt | sort -u"),
        ("Show the shells in use and how many users have each.", "cut -d: -f7 /etc/passwd | sort | uniq -c | sort -nr"),
    )
RECIPES[-1]["utility"]="cut"

@recipe("pipeline","curl")
def p_curl():
    h = R(HOSTS)
    return pick(
        (f"Fetch JSON from https://{h}/api/users and pretty-print it with jq.", f"curl -s https://{h}/api/users | jq ."),
        (f"get the number of items in the JSON array at https://{h}/api/items", f"curl -s https://{h}/api/items | jq 'length'"),
        (f"download https://{h}/list.txt and count the lines", f"curl -s https://{h}/list.txt | wc -l"),
        (f"extract all the 'name' fields from https://{h}/api/users", f"curl -s https://{h}/api/users | jq -r '.[].name'"),
    )
RECIPES[-1]["utility"]="curl"

@recipe("pipeline","ls")
def p_ls():
    d = R(DIRS); e = R(EXTS)
    return pick(
        (f"Count how many files are in {d}.", f"ls -1 {d} | wc -l"),
        (f"Find the most recently modified file in {d}.", f"ls -t {d} | head -n 1"),
        (f"list only the .{e} files in {d}", f"ls {d} | grep '\\.{e}$'"),
    )
RECIPES[-1]["utility"]="ls"

@recipe("pipeline","sed")
def p_sed():
    f = R(TEXTFILES)
    return pick(
        (f"Extract just the email addresses from {f}.", f"grep -oE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+' {f} | sort -u"),
        (f"strip leading whitespace from every line of {f} and save to clean.txt", f"sed 's/^[[:space:]]*//' {f} > clean.txt"),
        (f"replace tabs with commas in {f} and write to {f}.csv", f"sed 's/\\t/,/g' {f} > {f}.csv"),
    )
RECIPES[-1]["utility"]="sed"

@recipe("pipeline","xargs")
def p_xargs():
    port = R(PORTS)
    return pick(
        ("Read package names from packages.txt and install them all with apt.", "xargs -a packages.txt sudo apt install -y"),
        (f"kill every process listening on port {port}", f"lsof -ti :{port} | xargs -r kill -9"),
        ("Run 4 parallel gzip jobs over every .log file in the current dir.", "ls *.log | xargs -P4 -n1 gzip"),
    )
RECIPES[-1]["utility"]="xargs"

@recipe("pipeline","tar")
def p_tar():
    d = R(SDIRS); u = R(USERS); h = R(HOSTS)
    return pick(
        (f"Archive {d} and pipe it over ssh to back it up on a remote host.", f"tar -czf - {d} | ssh {u}@{h} 'cat > /backup/{d}.tar.gz'"),
        (f"count how many files are inside backup.tar.gz", "tar -tzf backup.tar.gz | wc -l"),
    )
RECIPES[-1]["utility"]="tar"

@recipe("pipeline","chain")
def p_chain():
    d = R(SDIRS); cf = R(FILES)
    return pick(
        (f"Create the {d} directory if needed and then cd into it.", f"mkdir -p {d} && cd {d}"),
        (f"Build the project and only deploy if the build succeeds.", "make build && ./deploy.sh"),
        (f"Try to restart nginx, and if that fails, print an error.", "sudo systemctl restart nginx || echo 'nginx restart failed' >&2"),
        (f"Run the tests and echo PASS or FAIL depending on the result.", "pytest -q && echo PASS || echo FAIL"),
        (f"Check if {cf} exists and cat it, otherwise say it's missing.", f"[ -f {cf} ] && cat {cf} || echo 'not found'"),
        (f"Pull latest code and restart the app service.", "git pull && sudo systemctl restart myapp"),
    )
RECIPES[-1]["utility"]="chain"

@recipe("pipeline","cmdsub")
def p_cmdsub():
    return pick(
        ("Create a backup file stamped with today's date.", "cp app.json app-$(date +%Y%m%d).json"),
        (f"Make a timestamped log directory under logs/.", "mkdir -p logs/$(date +%Y-%m-%d)"),
        ("Kill the process using the most memory. (Careful.)", "kill $(ps aux --sort=-%mem | awk 'NR==2 {print $2}')"),
        ("Tar up the current directory into a dated archive.", "tar -czf backup-$(date +%F).tar.gz ."),
        ("Print how many CPU cores this machine has.", "echo \"Cores: $(nproc)\""),
    )
RECIPES[-1]["utility"]="cmdsub"

@recipe("pipeline","free")
def p_free():
    return pick(
        ("Print the percentage of memory currently in use.", "free | awk '/Mem/ {printf \"%.1f%%\\n\", $3/$2*100}'"),
        ("Show just the amount of free memory in MB.", "free -m | awk '/Mem/ {print $4}'"),
    )
RECIPES[-1]["utility"]="free"

@recipe("pipeline","vmstat")
def p_vmstat():
    return pick(
        ("Extract the idle-CPU column from a vmstat snapshot.", "vmstat 1 2 | tail -n1 | awk '{print $15}'"),
        ("Log vmstat output to a file with timestamps every 5 seconds.", "vmstat 5 | while read line; do echo \"$(date '+%F %T') $line\"; done >> vmstat.log"),
    )
RECIPES[-1]["utility"]="vmstat"

@recipe("pipeline","dmesg")
def p_dmesg():
    return pick(
        ("Check dmesg for any out-of-memory killer events.", "dmesg -T | grep -i 'out of memory'"),
        ("Look for USB-related messages in the kernel log.", "dmesg -T | grep -i usb"),
    )
RECIPES[-1]["utility"]="dmesg"

@recipe("pipeline","redir")
def p_redir():
    f = R(LOGFILES)
    return pick(
        (f"Run the backup script, sending stdout and stderr to {f}.", f"./backup.sh > {f} 2>&1"),
        (f"Append the current date to {f}.", f"date >> {f}"),
        ("Discard all output from a noisy command.", "./noisy.sh > /dev/null 2>&1"),
        (f"Save errors to error.log and normal output to out.log separately.", "./run.sh > out.log 2> error.log"),
        ("Feed a here-string into base64.", "base64 <<< 'hello world'"),
    )
RECIPES[-1]["utility"]="redirection"

# ==========================================================================
# SCRIPT RECIPES  (multi-line)
# ==========================================================================
@recipe("script","for")
def s_for_rename():
    e1,e2 = R(["jpeg","JPG","txt","htm"]), R(["jpg","jpg","text","html"])
    return (
        f"Write a script that renames every .{e1} file in the current directory to .{e2}.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          f'for f in *.{e1}; do',
          '  [ -e "$f" ] || continue',
          f'  mv -- "$f" "${{f%.{e1}}}.{e2}"',
          'done')
    )

@recipe("script","for")
def s_for_batch():
    d = R(SDIRS)
    return (
        f"Loop over every .log file in {d} and gzip any that are larger than 10MB.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          f'for f in {d}/*.log; do',
          '  [ -e "$f" ] || continue',
          '  if [ "$(stat -c %s "$f")" -gt 10485760 ]; then',
          '    gzip "$f"',
          '    echo "compressed $f"',
          '  fi',
          'done')
    )

@recipe("script","while")
def s_while_read():
    f = R(["hosts.txt","servers.txt","urls.txt"])
    return (
        f"Read {f} line by line and ping each host once, reporting up or down.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          f'while IFS= read -r host; do',
          '  [ -z "$host" ] && continue',
          '  if ping -c1 -W1 "$host" >/dev/null 2>&1; then',
          '    echo "$host is UP"',
          '  else',
          '    echo "$host is DOWN"',
          '  fi',
          f'done < {f}')
    )

@recipe("script","if")
def s_if_disk():
    th = R([80,85,90,95])
    return (
        f"Write a script that alerts if the root filesystem is more than {th}% full.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          f'threshold={th}',
          "usage=$(df / | awk 'NR==2 {print $5}' | tr -d '%')",
          'if [ "$usage" -gt "$threshold" ]; then',
          f'  echo "WARNING: root filesystem is ${{usage}}% full (threshold ${{threshold}}%)" >&2',
          '  exit 1',
          'fi',
          'echo "Disk usage OK: ${usage}%"')
    )

@recipe("script","function")
def s_function_log():
    return (
        "Write a script with a reusable log() function that prefixes messages with a timestamp and severity.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          "log() {",
          '  local level="$1"; shift',
          '  printf \'%s [%s] %s\\n\' "$(date \'+%Y-%m-%d %H:%M:%S\')" "$level" "$*"',
          "}",
          'log INFO "starting job"',
          'log WARN "low disk space"',
          'log INFO "done"')
    )

@recipe("script","getopts")
def s_getopts():
    return (
        "Write a script that parses -f (file), -n (count) and -v (verbose) options with getopts.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          "verbose=0",
          "file=\"\"",
          "count=10",
          'usage() { echo "usage: $0 -f FILE [-n COUNT] [-v]" >&2; exit 1; }',
          'while getopts ":f:n:v" opt; do',
          '  case "$opt" in',
          '    f) file="$OPTARG" ;;',
          '    n) count="$OPTARG" ;;',
          '    v) verbose=1 ;;',
          '    *) usage ;;',
          '  esac',
          'done',
          '[ -n "$file" ] || usage',
          '[ "$verbose" -eq 1 ] && echo "reading $count lines from $file"',
          'head -n "$count" "$file"')
    )

@recipe("script","trap")
def s_trap_cleanup():
    return (
        "Write a script that creates a temp working directory and cleans it up on exit using a trap.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          'workdir="$(mktemp -d)"',
          'cleanup() { rm -rf "$workdir"; }',
          "trap cleanup EXIT",
          'echo "working in $workdir"',
          'echo "some data" > "$workdir/data.txt"',
          'wc -l "$workdir/data.txt"')
    )

@recipe("script","case")
def s_case_service():
    s = R(SERVICES)
    return (
        f"Write a start/stop/restart control script for the {s} service using a case statement.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          f'service={s}',
          'case "${1:-}" in',
          '  start)   sudo systemctl start "$service" ;;',
          '  stop)    sudo systemctl stop "$service" ;;',
          '  restart) sudo systemctl restart "$service" ;;',
          '  status)  systemctl status "$service" ;;',
          '  *) echo "usage: $0 {start|stop|restart|status}" >&2; exit 1 ;;',
          'esac')
    )

@recipe("script","tar")
def s_backup():
    d = R(["/home/deploy","/var/www","/etc","/opt/app"])
    return (
        f"Write a backup script that tars {d} into a timestamped archive under /backup and keeps only the 7 newest.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          f'src={d}',
          'dest=/backup',
          'mkdir -p "$dest"',
          'stamp=$(date +%Y%m%d-%H%M%S)',
          'archive="$dest/backup-$stamp.tar.gz"',
          'tar -czf "$archive" "$src"',
          'echo "created $archive"',
          '# retain only the 7 most recent backups',
          'ls -1t "$dest"/backup-*.tar.gz | tail -n +8 | xargs -r rm -f')
    )

@recipe("script","for")
def s_logrotate():
    return (
        "Write a simple log-rotation script that renames app.log to app.log.1..5 and truncates the current one.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          'log=app.log',
          'keep=5',
          'for i in $(seq $keep -1 1); do',
          '  prev=$((i-1))',
          '  if [ "$prev" -eq 0 ]; then',
          '    [ -f "$log" ] && mv "$log" "$log.1"',
          '  else',
          '    [ -f "$log.$prev" ] && mv "$log.$prev" "$log.$i"',
          '  fi',
          'done',
          ': > "$log"')
    )

@recipe("script","retry")
def s_retry():
    h = R(HOSTS)
    return (
        f"Write a script that retries a curl to https://{h}/health up to 5 times with a 2-second backoff.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          f'url=https://{h}/health',
          'max=5',
          'for attempt in $(seq 1 "$max"); do',
          '  if curl -fsS "$url" >/dev/null; then',
          '    echo "healthy on attempt $attempt"',
          '    exit 0',
          '  fi',
          '  echo "attempt $attempt failed, retrying..." >&2',
          '  sleep 2',
          'done',
          'echo "service never became healthy" >&2',
          'exit 1')
    )

@recipe("script","deploy")
def s_deploy():
    b = R(BRANCHES)
    return (
        f"Write a deployment script: pull the {b} branch, install deps, run tests, and restart the service only if tests pass.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          f'branch={b}',
          'echo "==> deploying $branch"',
          'git fetch origin',
          'git checkout "$branch"',
          'git pull --ff-only origin "$branch"',
          'npm ci',
          'if npm test; then',
          '  sudo systemctl restart myapp',
          '  echo "deploy succeeded"',
          'else',
          '  echo "tests failed, aborting deploy" >&2',
          '  exit 1',
          'fi')
    )
RECIPES[-1]["utility"]="git"

@recipe("script","heredoc")
def s_heredoc():
    return (
        "Write a script that generates an nginx config file for example.com using a here-document.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          'domain=example.com',
          'cat > "/etc/nginx/sites-available/$domain" <<EOF',
          'server {',
          '    listen 80;',
          '    server_name $domain;',
          '    root /var/www/$domain;',
          '    location / {',
          '        try_files \\$uri \\$uri/ =404;',
          '    }',
          '}',
          'EOF',
          'echo "wrote config for $domain"')
    )

@recipe("script","function")
def s_arg_check():
    return (
        "Write a script that requires exactly two arguments (source and destination) and errors out otherwise.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          'if [ "$#" -ne 2 ]; then',
          '  echo "usage: $0 SOURCE DEST" >&2',
          '  exit 1',
          'fi',
          'src="$1"',
          'dest="$2"',
          '[ -e "$src" ] || { echo "source $src does not exist" >&2; exit 1; }',
          'cp -r -- "$src" "$dest"',
          'echo "copied $src -> $dest"')
    )
RECIPES[-1]["utility"]="args"

@recipe("script","while")
def s_countdown():
    n = R([5,10,30])
    return (
        f"Write a countdown script from {n} to 1 that prints each number one second apart.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          f'i={n}',
          'while [ "$i" -gt 0 ]; do',
          '  echo "$i"',
          '  sleep 1',
          '  i=$((i - 1))',
          'done',
          'echo "liftoff"')
    )

@recipe("script","find")
def s_find_clean():
    d = R(["/tmp","/var/log","logs","cache"])
    days = R(DAYS)
    return (
        f"Write a script that deletes files older than {days} days from {d}, logging each removal.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          f'target={d}',
          f'age={days}',
          'find "$target" -type f -mtime +"$age" -print -delete | while IFS= read -r f; do',
          '  echo "$(date \'+%F %T\') removed $f"',
          'done >> cleanup.log')
    )
RECIPES[-1]["utility"]="find"

@recipe("script","function")
def s_menu():
    return (
        "Write an interactive menu script using select that lets the user pick disk, memory or uptime info.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          'PS3="Choose an option: "',
          'select opt in disk memory uptime quit; do',
          '  case "$opt" in',
          '    disk)   df -h ;;',
          '    memory) free -h ;;',
          '    uptime) uptime -p ;;',
          '    quit)   break ;;',
          '    *) echo "invalid choice" ;;',
          '  esac',
          'done')
    )
RECIPES[-1]["utility"]="select"

@recipe("script","if")
def s_check_root():
    return (
        "Write a script that refuses to run unless it's executed as root.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          'if [ "$(id -u)" -ne 0 ]; then',
          '  echo "this script must be run as root" >&2',
          '  exit 1',
          'fi',
          'echo "running with root privileges"')
    )

@recipe("script","for")
def s_mysql_backup():
    return (
        "Write a script that dumps every MySQL database into its own gzip file under /backup/db.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          'dest=/backup/db',
          'mkdir -p "$dest"',
          'stamp=$(date +%F)',
          'dbs=$(mysql -N -e "SHOW DATABASES" | grep -Ev "^(information_schema|performance_schema|mysql|sys)$")',
          'for db in $dbs; do',
          '  mysqldump --single-transaction "$db" | gzip > "$dest/${db}-${stamp}.sql.gz"',
          '  echo "dumped $db"',
          'done')
    )
RECIPES[-1]["utility"]="mysqldump"

@recipe("script","trap")
def s_lockfile():
    return (
        "Write a script that uses a lock file so only one instance can run at a time, releasing it on exit.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          'lock=/tmp/myjob.lock',
          'if [ -e "$lock" ]; then',
          '  echo "another instance is already running" >&2',
          '  exit 1',
          'fi',
          'touch "$lock"',
          'trap \'rm -f "$lock"\' EXIT',
          'echo "doing work..."',
          'sleep 2',
          'echo "done"')
    )

@recipe("script","while")
def s_watch_dir():
    d = R(SDIRS)
    return (
        f"Write a script that watches {d} and prints a message whenever the file count changes.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          f'dir={d}',
          'prev=$(ls -1 "$dir" | wc -l)',
          'while true; do',
          '  sleep 5',
          '  cur=$(ls -1 "$dir" | wc -l)',
          '  if [ "$cur" -ne "$prev" ]; then',
          '    echo "$(date \'+%T\'): count changed $prev -> $cur"',
          '    prev=$cur',
          '  fi',
          'done')
    )

@recipe("script","function")
def s_require_cmds():
    return (
        "Write a script that checks a list of required commands (git, curl, jq) are installed before continuing.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          'require() {',
          '  for cmd in "$@"; do',
          '    if ! command -v "$cmd" >/dev/null 2>&1; then',
          '      echo "missing required command: $cmd" >&2',
          '      exit 1',
          '    fi',
          '  done',
          '}',
          'require git curl jq',
          'echo "all dependencies present"')
    )
RECIPES[-1]["utility"]="command"

@recipe("script","for")
def s_batch_convert():
    return (
        "Write a script that converts every .png in the current directory to .jpg using ImageMagick, keeping originals.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          'shopt -s nullglob',
          'for img in *.png; do',
          '  out="${img%.png}.jpg"',
          '  convert "$img" "$out"',
          '  echo "converted $img -> $out"',
          'done')
    )

@recipe("script","if")
def s_process_check():
    p = R(PROCS)
    return (
        f"Write a script that checks whether {p} is running and starts it if not.",
        L("#!/usr/bin/env bash",
          "set -euo pipefail",
          f'proc={p}',
          'if pgrep -x "$proc" >/dev/null; then',
          '  echo "$proc is already running"',
          'else',
          '  echo "$proc not running, starting it"',
          '  sudo systemctl start "$proc"',
          'fi')
    )

# ---- high-capacity idiomatic families for info/system utilities -----------
def _F(forms):
    b, phr = random.choice(forms)
    return random.choice(phr), b

@recipe("single","vmstat")
def r_vmstat2():
    iv=R([1,2,3,5,10]); c=R([3,5,10,20,30])
    nl,b=_F([
      (f"vmstat {iv} {c}", (f"Report virtual-memory statistics every {iv} seconds, {c} times.",
        f"Sample vmstat {c} times at a {iv}-second interval.",
        f"Run vmstat every {iv}s and stop after {c} samples.",
        f"give me {c} vmstat readings spaced {iv} seconds apart")),
      (f"vmstat -S M {iv} {c}", (f"Show vmstat in megabytes, {iv}s interval, {c} samples.",
        f"Run vmstat with MB units every {iv} seconds for {c} rounds.")),
      (f"vmstat -a {iv}", (f"Watch active/inactive memory with vmstat every {iv}s.",
        f"Show active vs inactive memory using vmstat at {iv}-second intervals.")),
      (f"vmstat -w {iv} {c}", (f"Wide-format vmstat every {iv}s, {c} samples.",
        f"Use vmstat's wide output, {iv}s apart, {c} times.")),
      (f"vmstat -t {iv} {c}", (f"Timestamped vmstat every {iv}s for {c} samples.",
        f"Add a timestamp column to vmstat, {iv}s interval, {c} rounds.")),
      ("vmstat", ("Show a single virtual-memory snapshot.","Print current vmstat counters once.",
        "Give me a one-off vmstat summary.")),
      ("vmstat -s", ("Dump the vmstat table of memory and event counters.",
        "Show the full 'vmstat -s' statistics.","Print vmstat's summary-of-events table.")),
      ("vmstat -d", ("Show per-disk statistics with vmstat.","Report disk I/O counters via vmstat -d.")),
      ("vmstat -s -S M", ("Show vmstat memory counters in megabytes.",
        "Dump vmstat -s statistics using MB units.")),
    ])
    return nl, b, "vmstat"

@recipe("single","iostat")
def r_iostat2():
    iv=R([1,2,3,5,10]); c=R([3,5,10,20])
    nl,b=_F([
      (f"iostat {iv} {c}", (f"Show CPU and disk I/O stats every {iv} seconds, {c} times.",
        f"Sample iostat {c} times at {iv}-second intervals.",
        f"Run iostat every {iv}s for {c} reports.")),
      (f"iostat -x {iv} {c}", (f"Extended disk I/O stats every {iv}s, {c} samples.",
        f"Show detailed per-device iostat, {iv}s apart, {c} times.")),
      (f"iostat -xz {iv}", (f"Extended iostat every {iv}s, hiding idle devices.",
        f"Run iostat -x every {iv} seconds and skip zero-activity devices.")),
      (f"iostat -d {iv}", (f"Device-only I/O stats every {iv} seconds.",
        f"Show just disk stats with iostat every {iv}s.")),
      (f"iostat -m {iv} {c}", (f"I/O stats in MB/s every {iv}s for {c} samples.",
        f"Report iostat throughput in megabytes, {iv}s interval, {c} rounds.")),
      ("iostat -c", ("Show only the CPU utilization part of iostat.","Report CPU stats via iostat -c.")),
      ("iostat -xh", ("Show extended I/O stats in human-readable form.",
        "Give me iostat -x with human-readable units.")),
      ("iostat", ("Show a one-shot CPU and disk I/O summary.","Print current iostat counters once.")),
      (f"iostat -p sda {iv}", (f"Show per-partition stats for sda every {iv}s.",
        f"Monitor the sda device and its partitions with iostat every {iv} seconds.")),
    ])
    return nl, b, "iostat"

@recipe("single","free")
def r_free2():
    iv=R([1,2,3,5]); c=R([3,5,10])
    nl,b=_F([
      ("free -h", ("Show memory usage in human-readable units.","How much RAM is free right now?",
        "Display current memory usage nicely formatted.","give me a human-readable memory summary")),
      ("free -m", ("Show memory usage in megabytes.","Report free and used memory in MB.")),
      ("free -g", ("Show memory usage in gigabytes.","Display RAM usage rounded to GB.")),
      ("free -b", ("Show memory usage in bytes.","Report memory in raw bytes.")),
      ("free -h -t", ("Show memory usage with a total line for RAM plus swap.",
        "Include a combined RAM+swap total in the free output.")),
      ("free -w", ("Show memory usage with buffers and cache in separate columns.",
        "Give me the wide free output splitting buffers and cache.")),
      (f"free -h -s {iv}", (f"Refresh memory usage every {iv} seconds.",
        f"Watch memory continuously, updating every {iv}s.")),
      (f"free -m -s {iv} -c {c}", (f"Poll memory in MB every {iv}s, {c} times.",
        f"Sample free {c} times at {iv}-second intervals in megabytes.")),
      ("free -l", ("Show low and high memory statistics with free.","Display free's low/high memory breakdown.")),
      ("free -h --si", ("Show memory usage using powers of 1000 (SI units).",
        "Report memory in human-readable SI units.")),
    ])
    return nl, b, "free"

@recipe("single","uptime")
def r_uptime2():
    nl,b=_F([
      ("uptime", ("How long has the system been up?","Show uptime and load averages.",
        "Print the current uptime line.","what's the load average and uptime?",
        "Give me the one-line uptime summary.")),
      ("uptime -p", ("Show uptime in a human-friendly 'pretty' format.",
        "How long has this box been running, in plain words?","Print uptime -p.",
        "give me uptime in the pretty format")),
      ("uptime -s", ("When did the system last boot?","Show the exact boot timestamp.",
        "Print the system's startup date and time.","what time did the machine come up?")),
      ("cat /proc/uptime", ("Show raw uptime in seconds from /proc.",
        "Read the uptime directly out of /proc/uptime.")),
      ("awk '{print $1}' /proc/uptime", ("Print just the uptime in seconds.",
        "Extract the number of seconds the system has been up.")),
      ("awk '{print int($1/86400)\" days\"}' /proc/uptime", ("Show the uptime rounded to whole days.",
        "How many full days has the system been up?")),
      ("awk '{printf \"%d:%02d\\n\", $1/3600, ($1%3600)/60}' /proc/uptime", (
        "Show uptime formatted as hours:minutes.","Print how long the system has been up in H:MM.")),
      ("uptime | awk -F'load average:' '{print $2}'", ("Show only the load averages.",
        "Extract just the load-average part of uptime.")),
      ("uptime | grep -o 'load average.*'", ("Print only the load-average portion of uptime.",
        "Grep out the load averages from the uptime line.")),
      ("uptime | cut -d, -f1", ("Show only the time portion of the uptime line.",
        "Trim uptime down to just how long it's been up.")),
      ("cut -d' ' -f1 /proc/loadavg", ("Show the 1-minute load average.","Print the current 1-minute load.")),
      ("who -b", ("Show the last boot time using who.","When was the system booted, per who -b?")),
    ])
    return nl, b, "uptime"

@recipe("single","w")
def r_w2():
    u=R(USERS)
    nl,b=_F([
      ("w", ("Show who is logged in and what they're doing.","List active users and their processes.",
        "Who's on the system right now and running what?","Display the w summary of logged-in users.")),
      ("w -h", ("List logged-in users without the header line.","Show w output but skip the header.")),
      ("w -s", ("Show a short w listing without the login/JCPU/PCPU columns.",
        "Give me the abbreviated w output.")),
      ("w -i", ("Show logged-in users with their IP addresses instead of hostnames.",
        "Display w with numeric IPs.")),
      ("w -f", ("Show w output including the remote host each user came from.",
        "Include the FROM field in the w listing.")),
      (f"w {u}", (f"Show what user {u} is currently doing.",f"List {u}'s active sessions with w.",
        f"What is {u} running right now?")),
      (f"w -h {u}", (f"Show {u}'s sessions without the header.",f"List {u}'s activity, headerless.")),
      (f"w -s {u}", (f"Short w listing for user {u}.",f"Abbreviated session info for {u}.")),
      ("w | wc -l", ("Count how many entries w reports.","How many active sessions are there per w?")),
      ("w -h | wc -l", ("Count the number of logged-in user sessions.",
        "How many users are currently logged in?")),
    ])
    return nl, b, "w"

@recipe("single","hostname")
def r_hostname2():
    nl,b=_F([
      ("hostname", ("Print the system's hostname.","What is this machine's hostname?",
        "Show the short hostname.")),
      ("hostname -I", ("Print all IP addresses assigned to this host.",
        "What IPs does this machine have?","Show every local IP address, space separated.")),
      ("hostname -f", ("Show the fully qualified domain name.","What's the FQDN of this host?")),
      ("hostname -s", ("Show the short hostname (up to the first dot).","Print just the short hostname.")),
      ("hostname -d", ("Show the DNS domain name.","What domain is this host in?")),
      ("hostname -A", ("Show all FQDNs for this host.","List every fully-qualified name of the machine.")),
      ("hostname -i", ("Show the host's primary IP as resolved from its name.",
        "Print the IP address hostname resolves to.")),
      ("hostname -I | awk '{print $1}'", ("Print only the primary (first) IP address.",
        "Get just the first local IP address.")),
      ("uname -n", ("Show the network node hostname via uname.","Print the nodename with uname -n.")),
      ("cat /etc/hostname", ("Show the configured hostname from /etc/hostname.",
        "Read the hostname straight from its config file.")),
    ])
    return nl, b, "hostname"

@recipe("single","pstree")
def r_pstree2():
    u=R(USERS); pid=random.randint(500,9000)
    nl,b=_F([
      ("pstree -p", ("Show the process tree with PIDs.","Display the process hierarchy including PIDs.",
        "Print pstree annotated with process IDs.")),
      ("pstree", ("Show the process tree.","Display all processes as a hierarchy.")),
      ("pstree -a", ("Show the process tree including command-line arguments.",
        "Display pstree with each process's arguments.")),
      ("pstree -hp", ("Show the process tree with PIDs, highlighting the current process.",
        "Print pstree highlighting the current branch, with PIDs.")),
      ("pstree -n", ("Show the process tree sorted numerically by PID.",
        "Display pstree ordered by PID instead of by name.")),
      ("pstree -A", ("Show the process tree using ASCII line characters.",
        "Print pstree with ASCII art instead of Unicode.")),
      (f"pstree {u}", (f"Show the process tree for user {u}.",f"Display {u}'s processes as a tree.")),
      (f"pstree -p {u}", (f"Show {u}'s process tree with PIDs.",f"Print {u}'s process hierarchy including PIDs.")),
      (f"pstree -s {pid}", (f"Show the parent chain leading to PID {pid}.",
        f"Display the ancestors of process {pid} as a tree.")),
      (f"pstree -p {pid}", (f"Show the subtree of processes under PID {pid}.",
        f"Display the children of process {pid}.")),
    ])
    return nl, b, "pstree"

@recipe("single","dmesg")
def r_dmesg2():
    pat=R(["usb","memory","error","sda","sdb","eth0","enp0s3","oom","segfault","firmware",
           "tcp","cpu","disk","i/o","link","reset","timeout","nvme","kvm","thermal"])
    n=R([10,20,30,50,100]); since=R(["10 min ago","1 hour ago","today","30 min ago","yesterday"])
    fac=R(["kern","daemon","syslog","user"])
    nl,b=_F([
      ("dmesg -T", ("Show kernel messages with human-readable timestamps.",
        "Print the kernel ring buffer with real timestamps.","Display dmesg using -T timestamps.")),
      ("dmesg -w", ("Follow new kernel messages as they arrive.","Watch the kernel log live.")),
      ("dmesg -H", ("Show kernel messages in the pager with human-readable output.",
        "Display dmesg in human-friendly mode.")),
      ("dmesg -l err,warn", ("Show only kernel error and warning messages.",
        "Filter dmesg to errors and warnings.","Display kernel warnings and errors only.")),
      ("dmesg -l err", ("Show only kernel error-level messages.","Filter the kernel log to errors.")),
      ("dmesg -l warn", ("Show only kernel warning-level messages.","Filter dmesg to warnings.")),
      ("dmesg -l notice", ("Show kernel notice-level messages.","Filter the kernel log to notices.")),
      ("dmesg --level=crit", ("Show only critical kernel messages.","Filter dmesg to critical level.")),
      ("dmesg -x", ("Show kernel messages with facility and level decoded.",
        "Print dmesg with the facility/level prefix.")),
      ("dmesg -t", ("Show kernel messages without the timestamp prefix.","Print dmesg with timestamps stripped.")),
      ("dmesg -r", ("Show the raw kernel message buffer.","Print dmesg in raw format with priority markers.")),
      (f"dmesg -f {fac}", (f"Show kernel messages from the {fac} facility.",
        f"Filter dmesg to the {fac} facility.")),
      (f"dmesg -T --since '{since}'", (f"Show kernel messages since {since}.",
        f"Print dmesg entries from {since} onward with timestamps.")),
      (f"dmesg -T | tail -n {n}", (f"Show the last {n} kernel log lines with timestamps.",
        f"Print the most recent {n} dmesg entries.")),
      (f"dmesg -T | grep -i {pat}", (f"Search the kernel log for '{pat}' messages.",
        f"Find any dmesg lines mentioning {pat}.",f"Grep the kernel ring buffer for {pat}.")),
      (f"dmesg --level=err | grep -i {pat}", (f"Find kernel errors related to {pat}.",
        f"Show error-level dmesg lines mentioning {pat}.")),
      ("dmesg -k", ("Show only kernel-generated messages.","Restrict dmesg to kernel messages.")),
    ])
    return nl, b, "dmesg"

@recipe("single","netstat")
def r_netstat2():
    port=R(PORTS); h=R(HOSTS)
    nl,b=_F([
      ("netstat -tulpn", ("List all listening ports with the owning programs.",
        "Show listening TCP/UDP sockets and their PIDs.","What's listening on this machine and on which ports?")),
      ("netstat -rn", ("Show the kernel routing table numerically.","Print the routing table without DNS lookups.")),
      ("netstat -i", ("Show network interface statistics.","Display per-interface counters.")),
      ("netstat -s", ("Show summary statistics for each protocol.","Print protocol-level network stats.")),
      ("netstat -an", ("Show all sockets numerically.","List every connection without resolving names.")),
      ("netstat -tn", ("Show established TCP connections numerically.","List active TCP sessions with numeric addresses.")),
      ("netstat -ltn", ("Show listening TCP ports numerically.","List TCP listeners without name resolution.")),
      (f"netstat -anp | grep :{port}", (f"Show connections on port {port}.",
        f"Find any socket using port {port} via netstat.")),
      (f"netstat -tn | grep {h}", (f"Show TCP connections involving {h}.",
        f"Filter netstat for connections to or from {h}.")),
      ("netstat -tunlp", ("List all listening TCP and UDP ports with programs.",
        "Show every listening socket and its process.")),
    ])
    return nl, b, "netstat"

@recipe("single","nice")
def r_nice2():
    v=R([1,5,10,15,19,-5,-10]); c=random.randint(1000,9999)
    cmd=R(["tar -czf backup.tar.gz /home/deploy","python train.py","make -j4","ffmpeg -i in.mp4 out.mp4",
           "rsync -a /data /mnt/backup","gzip huge.log","./import.sh","npm run build",
           "find / -name '*.core'","dd if=/dev/zero of=test.img bs=1M count=1024"])
    if v < 0:
        nl,b=_F([
          (f"sudo nice -n {v} {cmd}", (f"Run '{cmd}' at higher priority (nice {v}); needs root.",
            f"Give '{cmd}' a boosted CPU priority of {v}.")),
        ])
    else:
        nl,b=_F([
          (f"nice -n {v} {cmd}", (f"Run '{cmd}' at a lower priority (nice {v}).",
            f"Start '{cmd}' with nice value {v} so it doesn't hog the CPU.",
            f"Launch '{cmd}' at reduced priority ({v}).")),
          (f"nice -n {v} {cmd} &", (f"Run '{cmd}' niced to {v} in the background.",
            f"Background '{cmd}' at nice level {v}.")),
        ])
    return nl, b, "nice"

# ---- high-capacity parameterized PIPELINE families (dynamic utility labels) -
@recipe("pipeline","freqtop")
def p_freqtop():
    f = R(LOGFILES + CSVFILES)
    fld = R([1,2,3,4,5,7,9]); n = R([5,10,15,20,25])
    sep, extract, util = R([
        ("whitespace-separated", f"awk '{{print ${fld}}}' {f}", "awk"),
        ("comma-separated", f"cut -d, -f{fld} {f}", "cut"),
    ])
    nl = pick(
        f"Show the top {n} most frequent values in field {fld} of the {sep} file {f}.",
        f"What are the {n} most common entries in column {fld} of {f}?",
        f"Rank the values of column {fld} in {f} by frequency, highest first, top {n} only.",
        f"Give me a frequency tally of column {fld} in {f} and show the {n} biggest.",
        f"In {f}, which {n} values of column {fld} occur most often?",
        f"Count how often each column-{fld} value appears in {f}; show the {n} most common.",
        f"From {f}, list the {n} most frequent field-{fld} entries with their counts.",
        f"Tally column {fld} of {f} and print the {n} top values by count.",
        f"Find the {n} hottest values in column {fld} of {f} (by frequency).",
    )
    return nl, f"{extract} | sort | uniq -c | sort -nr | head -n {n}", util

@recipe("pipeline","catpipe")
def p_catpipe():
    f = R(TEXTFILES)
    op, cmd, util = R([
        ("count the lines", "wc -l", "wc"),
        ("sort it and drop duplicate lines", "sort -u", "sort"),
        ("show the 20 longest lines", "awk '{ print length, $0 }' | sort -rn | head -20 | cut -d' ' -f2-", "awk"),
        ("convert everything to uppercase", "tr 'a-z' 'A-Z'", "tr"),
        ("show the last 15 lines", "tail -n 15", "tail"),
        ("keep only non-empty lines", "grep -v '^$'", "grep"),
        ("count each unique line, most common first", "sort | uniq -c | sort -nr", "uniq"),
        ("strip trailing whitespace", "sed 's/[[:space:]]*$//'", "sed"),
    ])
    nl = pick(f"Take {f} and {op}.", f"From {f}, {op}.",
              f"Read {f}, then {op} — as a pipeline.", f"Given {f}, {op}.")
    return nl, f"cat {f} | {cmd}", util

@recipe("pipeline","procpipe")
def p_procpipe():
    n = R([5,10,15]); p = R(PROCS)
    variant, bash, util = R([
        (f"show the top {n} processes by memory", f"ps aux --sort=-%mem | head -n {n+1}", "ps"),
        (f"show the top {n} processes by CPU usage", f"ps aux --sort=-%cpu | head -n {n+1}", "ps"),
        (f"total the resident memory of all {p} processes in MB", f"ps -C {p} -o rss= | awk '{{s+=$1}} END{{print s/1024 \" MB\"}}'", "ps"),
        (f"count how many {p} processes are running", f"pgrep -c {p}", "pgrep"),
        (f"list the PIDs of {p} sorted by memory use", f"ps -C {p} -o pid=,rss= --sort=-rss", "ps"),
    ])
    nl = pick(f"Help me {variant}.", f"{variant[0].upper()+variant[1:]}.", f"How do I {variant}?")
    return nl, bash, util

@recipe("pipeline","netpipe")
def p_netpipe():
    n = R([5,10,20])
    variant, bash, util = R([
        ("count established TCP connections", "ss -tn state established | tail -n +2 | wc -l", "ss"),
        (f"list the top {n} remote IPs by number of connections", f"ss -tn | awk 'NR>1 {{print $5}}' | cut -d: -f1 | sort | uniq -c | sort -nr | head -n {n}", "ss"),
        ("show which processes are listening and on which ports", "ss -tlnp | awk 'NR>1 {print $4, $6}'", "ss"),
        (f"find the {n} processes with the most open files", f"lsof 2>/dev/null | awk '{{print $1}}' | sort | uniq -c | sort -nr | head -n {n}", "lsof"),
        ("count connections grouped by their TCP state", "ss -tan | awk 'NR>1 {print $1}' | sort | uniq -c | sort -nr", "ss"),
    ])
    nl = pick(f"On this box, {variant}.", f"I want to {variant}.", f"Write a one-liner to {variant}.")
    return nl, bash, util

@recipe("pipeline","logscan")
def p_logscan():
    s = R(SERVICES); f = R(LOGFILES); p = R(PATTERNS); n = R([10,20,50])
    variant, bash, util = R([
        (f"count '{p}' occurrences in the {s} journal today", f"journalctl -u {s} --since today --no-pager | grep -c '{p}'", "journalctl"),
        (f"show the last {n} lines containing '{p}' in {f}", f"grep '{p}' {f} | tail -n {n}", "grep"),
        (f"tally how many times each log level appears in {f}", f"grep -oE '(INFO|WARN|ERROR|DEBUG)' {f} | sort | uniq -c | sort -nr", "grep"),
        (f"list the unique '{p}' messages in {f}", f"grep '{p}' {f} | sort -u", "grep"),
        (f"follow the {s} journal but only show lines mentioning '{p}'", f"journalctl -u {s} -f | grep --line-buffered -i '{p}'", "journalctl"),
    ])
    nl = pick(f"I need to {variant}.", f"{variant[0].upper()+variant[1:]}.", f"Show me how to {variant}.")
    return nl, bash, util

@recipe("pipeline","diskpipe")
def p_diskpipe():
    d = R(DIRS); n = R([5,10,20])
    variant, bash, util = R([
        (f"the {n} biggest files under {d}", f"find {d} -type f -printf '%s %p\\n' 2>/dev/null | sort -rn | head -n {n}", "find"),
        (f"the {n} largest subdirectories of {d}", f"du -h {d}/* 2>/dev/null | sort -rh | head -n {n}", "du"),
        ("how full each mounted filesystem is, worst first", "df -h | awk 'NR>1 {print $5, $6}' | sort -rn", "df"),
        (f"the disk usage of {d} broken down one level deep", f"du -h --max-depth=1 {d} 2>/dev/null | sort -rh", "du"),
    ])
    nl = pick(f"Show me {variant}.", f"What are {variant}?", f"List {variant}.")
    return nl, bash, util

@recipe("single","fileq")
def r_fileq():
    f = R(FILES)
    variant, bash, util = R([
        ("show the first 20 lines", f"head -n 20 {f}", "head"),
        ("show the last 20 lines", f"tail -n 20 {f}", "tail"),
        ("count the lines", f"wc -l {f}", "wc"),
        ("print it with line numbers", f"nl {f}", "nl"),
        ("show its size, owner and permissions", f"stat {f}", "stat"),
        ("determine what kind of file it is", f"file {f}", "file"),
        ("show just the first line", f"head -n 1 {f}", "head"),
        ("show a hex dump of the first 64 bytes", f"xxd -l 64 {f}", "xxd"),
    ])
    nl = pick(f"For {f}, {variant}.", f"{variant[0].upper()+variant[1:]} of {f}.",
              f"Please {variant} in {f}.", f"On the file {f}, {variant}.")
    return nl, bash, util

# ---- high-capacity parameterized script families (dynamic utility labels) --
WORKDIRS = ["/home/deploy","/var/www","/opt/app","/srv/data","/home/alice",
            "/var/lib/app","/data/uploads","/mnt/storage","logs","data","backups"]
BACKDESTS = ["/backup","/mnt/backup","/var/backups","/srv/backup","/data/backup"]
KEEPS = [3,5,7,10,14,30]
THRESH = [70,75,80,85,90,95]

_FILE_ACTIONS = [
    ("compresses each file with gzip", 'gzip -- "$f"', "gzip"),
    ("removes each matching file", 'rm -f -- "$f"', "rm"),
    ("makes each file read-only", 'chmod 444 -- "$f"', "chmod"),
    ("makes a .bak copy of each file", 'cp -- "$f" "$f.bak"', "cp"),
    ("prints the line count of each file", 'wc -l -- "$f"', "wc"),
    ("moves each file into an archive/ subfolder", 'mv -- "$f" archive/', "mv"),
    ("changes the owner of each file to deploy", 'chown deploy -- "$f"', "chown"),
]
@recipe("script","fileproc")
def s_fileproc():
    d = R(WORKDIRS); e = R(EXTS); desc, act, util = R(_FILE_ACTIONS)
    nl = pick(
        f"Write a script that loops over every .{e} file in {d} and {desc}.",
        f"I need a bash script that {desc} for all .{e} files under {d}.",
        f"Loop through the .{e} files in {d} and {desc} — write it as a proper script.",
        f"Give me a script that iterates over {d}/*.{e} and {desc}.",
    )
    body = L("#!/usr/bin/env bash",
             "set -euo pipefail",
             f'dir={d}',
             f'for f in "$dir"/*.{e}; do',
             '  [ -e "$f" ] || continue',
             f'  {act}',
             '  echo "processed $f"',
             'done')
    return nl, body, util

_RES_MON = [
    ("root filesystem usage", "df / | awk 'NR==2 {print $5}' | tr -d '%'", "disk usage"),
    ("memory usage", "free | awk '/Mem/ {printf \"%d\", $3/$2*100}'", "memory usage"),
    ("the /home partition usage", "df /home | awk 'NR==2 {print $5}' | tr -d '%'", "/home usage"),
    ("swap usage", "free | awk '/Swap/ {if($2>0) printf \"%d\", $3/$2*100; else print 0}'", "swap usage"),
]
@recipe("script","monitor")
def s_monitor():
    label, expr, human = R(_RES_MON); th = R(THRESH)
    util = "df" if "df" in expr else "free"
    nl = pick(
        f"Write a monitoring script that warns when {label} exceeds {th}%.",
        f"Alert me (exit non-zero) if {label} goes above {th} percent.",
        f"I want a script checking {label}; if it's over {th}% print a warning to stderr.",
    )
    body = L("#!/usr/bin/env bash",
             "set -euo pipefail",
             f'threshold={th}',
             f'usage=$({expr})',
             'if [ "$usage" -gt "$threshold" ]; then',
             f'  echo "ALERT: {human} is at ${{usage}}% (limit ${{threshold}}%)" >&2',
             '  exit 1',
             'fi',
             f'echo "{human} OK at ${{usage}}%"')
    return nl, body, util

@recipe("script","backup2")
def s_backup2():
    src = R(WORKDIRS); dest = R(BACKDESTS); keep = R(KEEPS)
    comp, flag, ext = R([("gzip","z","gz"),("bzip2","j","bz2"),("xz","J","xz")])
    nl = pick(
        f"Write a backup script that {comp}-compresses {src} into a timestamped tarball under {dest} and keeps only the {keep} newest.",
        f"Back up {src} to {dest} as a dated {comp} archive, pruning all but the last {keep} backups.",
        f"I need a rotating backup: archive {src} into {dest} with {comp}, retain {keep} copies.",
    )
    body = L("#!/usr/bin/env bash",
             "set -euo pipefail",
             f'src={src}',
             f'dest={dest}',
             f'keep={keep}',
             'mkdir -p "$dest"',
             'stamp=$(date +%Y%m%d-%H%M%S)',
             f'archive="$dest/$(basename "$src")-$stamp.tar.{ext}"',
             f'tar -c{flag}f "$archive" "$src"',
             'echo "created $archive"',
             'ls -1t "$dest"/*.tar.* | tail -n +$((keep + 1)) | xargs -r rm -f')
    return nl, body, "tar"

@recipe("script","hosts")
def s_hosts_iter():
    f = R(["hosts.txt","servers.txt","nodes.txt","targets.txt"])
    action, cmd, util = R([
        ("pings each host once", 'ping -c1 -W1 "$host" >/dev/null 2>&1', "ping"),
        ("checks if port 22 is open", 'timeout 2 bash -c "echo > /dev/tcp/$host/22" 2>/dev/null', "ssh"),
        ("curls the /health endpoint", 'curl -fsS "http://$host/health" >/dev/null', "curl"),
    ])
    nl = pick(
        f"Read {f} and for each host, report UP/DOWN based on whether it {action}.",
        f"Write a health-check loop over {f} that {action} and prints the status of each.",
        f"Iterate the hosts in {f}; the script {action} and marks each reachable or not.",
    )
    body = L("#!/usr/bin/env bash",
             "set -euo pipefail",
             'while IFS= read -r host; do',
             '  [ -z "$host" ] && continue',
             '  case "$host" in \\#*) continue ;; esac',
             f'  if {cmd}; then',
             '    echo "$host UP"',
             '  else',
             '    echo "$host DOWN"',
             '  fi',
             f'done < {f}')
    return nl, body, util

@recipe("script","getopts2")
def s_getopts2():
    a,b,c = random.sample(["input","output","count","name","dir","level","port","tag"],3)
    fa,fb,fc = a[0], b[0], c[0]
    nl = pick(
        f"Write a script that accepts --{a} (-{fa}), --{b} (-{fb}) and --{c} (-{fc}) via getopts, with a usage message.",
        f"Parse command-line flags -{fa} ({a}), -{fb} ({b}) and -{fc} ({c}) using getopts and validate that -{fa} is provided.",
        f"I need getopts handling for three options: -{fa}, -{fb} and -{fc}; print usage on bad input.",
    )
    body = L("#!/usr/bin/env bash",
             "set -euo pipefail",
             f'{a}=""; {b}=""; {c}=""',
             f'usage() {{ echo "usage: $0 -{fa} {a.upper()} [-{fb} {b.upper()}] [-{fc} {c.upper()}]" >&2; exit 1; }}',
             f'while getopts ":{fa}:{fb}:{fc}:" opt; do',
             '  case "$opt" in',
             f'    {fa}) {a}="$OPTARG" ;;',
             f'    {fb}) {b}="$OPTARG" ;;',
             f'    {fc}) {c}="$OPTARG" ;;',
             '    *) usage ;;',
             '  esac',
             'done',
             f'[ -n "${{{a}}}" ] || usage',
             f'echo "{a}=${{{a}}} {b}=${{{b}}} {c}=${{{c}}}"')
    return nl, body, "getopts"

@recipe("script","retry2")
def s_retry2():
    h = R(HOSTS); mx = R([3,4,5,6,10]); sl = R([1,2,3,5])
    thing, cmd, util = R([
        ("curl to https://%s/health" % h, f'curl -fsS "https://{h}/health" >/dev/null', "curl"),
        ("connection to %s:5432" % h, f'timeout 2 bash -c "echo > /dev/tcp/{h}/5432"', "bash"),
        ("git fetch from origin", 'git fetch origin', "git"),
    ])
    nl = pick(
        f"Write a script that retries a {thing} up to {mx} times, sleeping {sl}s between attempts.",
        f"Retry {thing} at most {mx} times with a {sl}-second backoff, failing loudly if it never succeeds.",
        f"I need a retry wrapper around {thing}: {mx} attempts, {sl}s apart.",
    )
    body = L("#!/usr/bin/env bash",
             "set -euo pipefail",
             f'max={mx}',
             f'delay={sl}',
             'for attempt in $(seq 1 "$max"); do',
             f'  if {cmd}; then',
             '    echo "succeeded on attempt $attempt"',
             '    exit 0',
             '  fi',
             '  echo "attempt $attempt failed" >&2',
             '  sleep "$delay"',
             'done',
             'echo "giving up after $max attempts" >&2',
             'exit 1')
    return nl, body, util

@recipe("script","findclean2")
def s_findclean2():
    d = R(["/tmp","/var/log","/var/cache","logs","cache","uploads","/var/tmp"])
    days = R(DAYS); e = R(["log","tmp","bak","gz","old","cache"])
    nl = pick(
        f"Write a script that deletes .{e} files older than {days} days from {d} and logs what it removed.",
        f"Clean up {d}: remove .{e} files not modified in {days} days, recording each deletion.",
        f"I want a cleanup script for {d} that purges .{e} files older than {days} days.",
    )
    body = L("#!/usr/bin/env bash",
             "set -euo pipefail",
             f'target={d}',
             f'age={days}',
             '[ -d "$target" ] || { echo "no such dir: $target" >&2; exit 1; }',
             f'find "$target" -type f -name "*.{e}" -mtime +"$age" -print -delete \\',
             '  | sed "s/^/removed /" | tee -a cleanup.log')
    return nl, body, "find"

@recipe("script","funcs2")
def s_funcs2():
    lv = R(["INFO","DEBUG","NOTICE"])
    nl = pick(
        "Write a script with a die() helper that logs an error to stderr and exits, plus a log() helper for info messages.",
        "I want reusable log() and die() shell functions with timestamps; die should exit 1.",
        "Give me a small bash logging library: log() writes info, die() writes an error and aborts.",
    )
    body = L("#!/usr/bin/env bash",
             "set -euo pipefail",
             "ts() { date '+%Y-%m-%d %H:%M:%S'; }",
             f'log() {{ printf \'%s [{lv}] %s\\n\' "$(ts)" "$*"; }}',
             'die() { printf \'%s [ERROR] %s\\n\' "$(ts)" "$*" >&2; exit 1; }',
             'log "starting"',
             '[ -f config.yaml ] || die "config.yaml is missing"',
             'log "config found, continuing"')
    return nl, body, "function"

@recipe("script","dbdump")
def s_dbdump():
    dest = R(BACKDESTS); keep = R(KEEPS)
    engine, listcmd, dumpcmd, util = R([
        ("MySQL", 'mysql -N -e "SHOW DATABASES"', "mysqldump --single-transaction", "mysqldump"),
        ("PostgreSQL", "psql -tAc 'SELECT datname FROM pg_database WHERE NOT datistemplate'", "pg_dump", "pg_dump"),
    ])
    nl = pick(
        f"Write a script that dumps every {engine} database into its own gzip file under {dest}, keeping {keep} days.",
        f"Back up all {engine} databases individually to {dest} as compressed dumps.",
        f"I need per-database {engine} backups written to {dest} and pruned after {keep} days.",
    )
    body = L("#!/usr/bin/env bash",
             "set -euo pipefail",
             f'dest={dest}',
             f'keep={keep}',
             'mkdir -p "$dest"',
             'stamp=$(date +%F)',
             f'for db in $({listcmd}); do',
             f'  {dumpcmd} "$db" | gzip > "$dest/${{db}}-${{stamp}}.sql.gz"',
             '  echo "dumped $db"',
             'done',
             'find "$dest" -name "*.sql.gz" -mtime +"$keep" -delete')
    return nl, body, util

@recipe("script","parallel")
def s_parallel():
    d = R(WORKDIRS); e = R(EXTS); n = R([2,4,8])
    tool, cmd, util = R([
        ("gzip", 'gzip', "gzip"),
        ("checksum with sha256sum", 'sha256sum', "sha256sum"),
        ("optipng", 'optipng', "optipng"),
    ])
    nl = pick(
        f"Write a script that runs {tool} on every .{e} file in {d}, {n} jobs in parallel.",
        f"Process all .{e} files under {d} with {tool} using {n} parallel workers via xargs.",
    )
    body = L("#!/usr/bin/env bash",
             "set -euo pipefail",
             f'dir={d}',
             f'find "$dir" -type f -name "*.{e}" -print0 \\',
             f'  | xargs -0 -P {n} -n1 {cmd}',
             'echo "done"')
    return nl, body, "xargs"

@recipe("script","envcheck")
def s_envcheck():
    v1,v2,v3 = random.sample(["API_KEY","DB_HOST","DB_PASS","AWS_REGION","REDIS_URL","PORT","ENV"],3)
    nl = pick(
        f"Write a script that verifies the environment variables {v1}, {v2} and {v3} are all set before running.",
        f"Fail fast if any of {v1}, {v2}, {v3} is unset — write it as a bash guard.",
        f"I need a preflight check that {v1}, {v2} and {v3} exist in the environment.",
    )
    body = L("#!/usr/bin/env bash",
             "set -euo pipefail",
             f'for var in {v1} {v2} {v3}; do',
             '  if [ -z "${!var:-}" ]; then',
             '    echo "required environment variable $var is not set" >&2',
             '    exit 1',
             '  fi',
             'done',
             'echo "environment looks good"')
    return nl, body, "env"

@recipe("script","for")
def s_for_big():
    kind = random.randint(0,4)
    if kind == 0:
        base = R(BACKDESTS); n = R([3,5,7,14,30])
        nl = pick(f"Write a script that pre-creates dated subdirectories under {base} for the next {n} days.",
                  f"Make {n} day-stamped folders under {base} using a for loop over a date range.")
        body = L("#!/usr/bin/env bash","set -euo pipefail",f'base={base}',
                 f'for i in $(seq 0 {n-1}); do',
                 '  day=$(date -d "+$i day" +%Y-%m-%d)',
                 '  mkdir -p "$base/$day"',
                 '  echo "created $base/$day"','done')
        return nl, body, "for"
    if kind == 1:
        d = R(WORKDIRS); e = R(EXTS)
        nl = pick(f"Loop over every .{e} file in {d} and append its sha256 checksum to checksums.txt.",
                  f"For each .{e} file under {d}, record a sha256 checksum in a manifest file.")
        body = L("#!/usr/bin/env bash","set -euo pipefail","shopt -s nullglob",
                 f'for f in {d}/*.{e}; do',
                 '  sha256sum "$f" >> checksums.txt',
                 'done',
                 'echo "wrote $(wc -l < checksums.txt) checksums"')
        return nl, body, "for"
    if kind == 2:
        svcs = " ".join(random.sample(SERVICES, 3))
        nl = pick(f"Write a loop that restarts these services in order: {svcs}.",
                  f"Restart {svcs} one after another and report each result.")
        body = L("#!/usr/bin/env bash","set -euo pipefail",
                 f'for svc in {svcs}; do',
                 '  if sudo systemctl restart "$svc"; then',
                 '    echo "$svc restarted"',
                 '  else',
                 '    echo "failed to restart $svc" >&2',
                 '  fi','done')
        return nl, body, "for"
    if kind == 3:
        d = R(WORKDIRS)
        nl = pick(f"Loop over all subdirectories of {d} and print each one's total size.",
                  f"For every immediate subdirectory of {d}, show how much disk it uses.")
        body = L("#!/usr/bin/env bash","set -euo pipefail",
                 f'for dir in {d}/*/; do',
                 '  [ -d "$dir" ] || continue',
                 '  size=$(du -sh "$dir" | cut -f1)',
                 '  printf "%-40s %s\\n" "$dir" "$size"','done')
        return nl, body, "for"
    prefix = R(["img","photo","scan","doc","page","frame"]); e = R(["jpg","png","txt","pdf"])
    nl = pick(f"Rename all .{e} files in the current folder to {prefix}_001.{e}, {prefix}_002.{e}, ... sequentially.",
              f"Batch-number every .{e} file as {prefix}_NNN.{e} using a counter in a for loop.")
    body = L("#!/usr/bin/env bash","set -euo pipefail","shopt -s nullglob","i=1",
             f'for f in *.{e}; do',
             f'  printf -v newname "{prefix}_%03d.{e}" "$i"',
             '  mv -- "$f" "$newname"',
             '  i=$((i + 1))','done')
    return nl, body, "for"

@recipe("script","while")
def s_while_big():
    kind = random.randint(0,3)
    if kind == 0:
        f = R(["hosts.txt","servers.txt","urls.txt","targets.txt","nodes.txt"])
        nl = pick(f"Read {f} line by line, skipping comments and blanks, and echo each entry numbered.",
                  f"Process {f} one line at a time, ignoring # comments, printing a running index.")
        body = L("#!/usr/bin/env bash","set -euo pipefail","n=0",
                 'while IFS= read -r line; do',
                 '  [ -z "$line" ] && continue',
                 '  case "$line" in \\#*) continue ;; esac',
                 '  n=$((n + 1))',
                 '  printf "%3d: %s\\n" "$n" "$line"',
                 f'done < {f}')
        return nl, body, "while"
    if kind == 1:
        c = R(CSVFILES)
        nl = pick(f"Read the CSV {c} field by field (id,name,email) with a while loop and print a greeting.",
                  f"Parse {c} as comma-separated id,name,email using while read and print each name.")
        body = L("#!/usr/bin/env bash","set -euo pipefail",
                 f'while IFS=, read -r id name email; do',
                 '  [ "$id" = "id" ] && continue',
                 '  echo "Hello $name <$email> (#$id)"',
                 f'done < {c}')
        return nl, body, "while"
    if kind == 2:
        th = R(THRESH)
        nl = pick(f"Write a watchdog loop that checks every 10s and only alerts once when disk passes {th}%.",
                  f"Poll disk usage every 10 seconds; warn a single time when it first exceeds {th}%.")
        body = L("#!/usr/bin/env bash","set -euo pipefail",f'limit={th}',"alerted=0",
                 'while true; do',
                 "  usage=$(df / | awk 'NR==2 {print $5}' | tr -d '%')",
                 '  if [ "$usage" -ge "$limit" ] && [ "$alerted" -eq 0 ]; then',
                 '    echo "disk crossed ${limit}% (now ${usage}%)" >&2',
                 '    alerted=1',
                 '  fi',
                 '  sleep 10','done')
        return nl, body, "while"
    n = R([10,20,50,100])
    nl = pick(f"Use a while loop to print the numbers 1 to {n}, but only the even ones.",
              f"Print even numbers up to {n} with a while loop and a counter.")
    body = L("#!/usr/bin/env bash","set -euo pipefail","i=2",f'max={n}',
             'while [ "$i" -le "$max" ]; do',
             '  echo "$i"',
             '  i=$((i + 2))','done')
    return nl, body, "while"

@recipe("script","if")
def s_if_big():
    kind = random.randint(0,3)
    if kind == 0:
        f = R(FILES)
        nl = pick(f"Write a script that checks whether {f} exists and is non-empty, printing an appropriate message.",
                  f"Test if {f} is present and has content; report missing, empty, or its line count.")
        body = L("#!/usr/bin/env bash","set -euo pipefail",f'file={f}',
                 'if [ ! -e "$file" ]; then',
                 '  echo "$file does not exist" >&2; exit 1',
                 'elif [ ! -s "$file" ]; then',
                 '  echo "$file exists but is empty"',
                 'else',
                 '  echo "$file has $(wc -l < "$file") lines"',
                 'fi')
        return nl, body, "if"
    if kind == 1:
        p = R(PROCS)
        nl = pick(f"Check whether {p} is running and exit 0 if so, 1 otherwise, with a message.",
                  f"Write a health check that reports UP/DOWN for the {p} process via its exit code.")
        body = L("#!/usr/bin/env bash","set -euo pipefail",f'proc={p}',
                 'if pgrep -x "$proc" >/dev/null 2>&1; then',
                 '  echo "$proc is running"; exit 0',
                 'else',
                 '  echo "$proc is NOT running" >&2; exit 1',
                 'fi')
        return nl, body, "if"
    if kind == 2:
        nl = pick("Write a script that verifies it is run with at least one argument, else prints usage.",
                  "Guard a script so it requires one or more arguments and shows usage otherwise.")
        body = L("#!/usr/bin/env bash","set -euo pipefail",
                 'if [ "$#" -lt 1 ]; then',
                 '  echo "usage: $0 ARG [ARG...]" >&2',
                 '  exit 2',
                 'fi',
                 'echo "got $# argument(s): $*"')
        return nl, body, "if"
    h = R(HOSTS)
    nl = pick(f"Ping {h} once and branch: print reachable or unreachable based on the result.",
              f"Write an if that checks connectivity to {h} with a single ping.")
    body = L("#!/usr/bin/env bash","set -euo pipefail",f'host={h}',
             'if ping -c1 -W2 "$host" >/dev/null 2>&1; then',
             '  echo "$host is reachable"',
             'else',
             '  echo "$host is unreachable" >&2',
             'fi')
    return nl, body, "if"

@recipe("script","case")
def s_case_big():
    kind = random.randint(0,2)
    if kind == 0:
        s = R(SERVICES)
        nl = pick(f"Write a start/stop/restart/status control script for {s} using a case statement.",
                  f"Give me an init-style dispatcher for the {s} service with case on $1.")
        body = L("#!/usr/bin/env bash","set -euo pipefail",f'svc={s}',
                 'case "${1:-}" in',
                 '  start)   sudo systemctl start "$svc" ;;',
                 '  stop)    sudo systemctl stop "$svc" ;;',
                 '  restart) sudo systemctl restart "$svc" ;;',
                 '  status)  systemctl status "$svc" ;;',
                 '  *) echo "usage: $0 {start|stop|restart|status}" >&2; exit 1 ;;',
                 'esac')
        return nl, body, "case"
    if kind == 1:
        e = R(["jpg","png","gif","pdf","txt","log","tar.gz","zip","mp4","csv"])
        nl = pick(f"Write a script that categorizes a filename by extension using case (is a .{e} an image, archive, doc?).",
                  "Classify a file passed as $1 into image/archive/document/other with a case on its extension.")
        body = L("#!/usr/bin/env bash","set -euo pipefail",'file="${1:?usage: $0 FILE}"',
                 'case "$file" in',
                 '  *.jpg|*.png|*.gif) echo "image" ;;',
                 '  *.tar.gz|*.zip|*.gz) echo "archive" ;;',
                 '  *.pdf|*.txt|*.md) echo "document" ;;',
                 '  *) echo "other" ;;',
                 'esac')
        return nl, body, "case"
    nl = pick("Write a script that reads a yes/no answer and handles Y/y/yes and N/n/no with a case statement.",
              "Handle a confirmation prompt: accept yes/no in any capitalization using case.")
    body = L("#!/usr/bin/env bash","set -euo pipefail",'answer="${1:-no}"',
             'case "${answer,,}" in',
             '  y|yes) echo "proceeding" ;;',
             '  n|no)  echo "aborting"; exit 1 ;;',
             '  *) echo "please answer yes or no" >&2; exit 2 ;;',
             'esac')
    return nl, body, "case"

@recipe("script","function")
def s_func_big():
    kind = random.randint(0,2)
    if kind == 0:
        nl = pick("Write a script with a confirm() function that asks the user to confirm before a destructive action.",
                  "Give me a reusable confirm() helper that returns success only on an explicit yes.")
        body = L("#!/usr/bin/env bash","set -euo pipefail",
                 'confirm() {',
                 '  read -r -p "${1:-Are you sure?} [y/N] " reply',
                 '  case "${reply,,}" in y|yes) return 0 ;; *) return 1 ;; esac',
                 '}',
                 'if confirm "Delete all temp files?"; then',
                 '  echo "deleting..."',
                 'else',
                 '  echo "cancelled"',
                 'fi')
        return nl, body, "function"
    if kind == 1:
        n = R([3,4,5])
        nl = pick(f"Write a retry() function that runs any command up to {n} times until it succeeds.",
                  f"Give me a generic retry wrapper function (max {n} tries) I can call with any command.")
        body = L("#!/usr/bin/env bash","set -euo pipefail",
                 'retry() {',
                 f'  local max={n} i=1',
                 '  until "$@"; do',
                 '    if [ "$i" -ge "$max" ]; then',
                 '      echo "command failed after $max attempts: $*" >&2',
                 '      return 1',
                 '    fi',
                 '    i=$((i + 1)); sleep 1',
                 '  done',
                 '}',
                 'retry curl -fsS https://api.example.com/health')
        return nl, body, "function"
    nl = pick("Write a script defining a human-readable size formatter function and use it on a file.",
              "Give me a bytes-to-human function and demonstrate it on a file's size.")
    body = L("#!/usr/bin/env bash","set -euo pipefail",
             'human() {',
             '  local b=$1 units=(B K M G T) i=0',
             '  while [ "$b" -ge 1024 ] && [ "$i" -lt 4 ]; do',
             '    b=$((b / 1024)); i=$((i + 1))',
             '  done',
             '  echo "${b}${units[$i]}"',
             '}',
             'human "$(stat -c %s "${1:-/etc/hostname}")"')
    return nl, body, "function"

@recipe("script","report")
def s_report_big():
    d = R(WORKDIRS); e = R(EXTS)
    nl = pick(f"Write a script that prints a small system report: hostname, uptime, disk and memory usage.",
              f"Generate a status summary showing host, load, free memory and root disk usage.",
              f"I want a one-shot health report script covering uptime, memory and disk.")
    body = L("#!/usr/bin/env bash","set -euo pipefail",
             "mem=$(free -h | awk '/Mem/ {print $3\"/\"$2}')",
             "disk=$(df -h / | awk 'NR==2 {print $3\"/\"$2\" (\"$5\")\"}')",
             "load=$(cut -d' ' -f1-3 /proc/loadavg)",
             'echo "===== system report ====="',
             'echo "host:   $(hostname)"',
             'echo "uptime: $(uptime -p)"',
             'echo "load:   $load"',
             'echo "memory: $mem"',
             'echo "disk:   $disk"')
    return nl, body, "report"

# --------------------------------------------------------------------------
# v2: degeneracy guard, answer-equivalence, seed ingestion
# --------------------------------------------------------------------------
_DESTRUCTIVE = re.compile(
    r"(?:^|[\s;&|(])(?:rm|dd|mkfs(?:\.\w+)?|shred|shutdown|reboot|halt|poweroff|"
    r"fdisk|parted|wipefs)\b"
    r"|\bof=/dev/|>\s*/dev/sd|/dev/sd\w")
def _is_destructive(bash):
    if ":(){" in bash.replace(" ", ""):        # fork bomb
        return True
    return bool(_DESTRUCTIVE.search(bash))

def categorize(bash):
    """single | pipeline | script, inferred from a command's shape."""
    if "\n" in bash.strip():
        return "script"
    if re.search(r"\|\||&&|[|;]|\$\(|`|\bxargs\b", bash):
        return "pipeline"
    return "single"

_UTIL_SKIP = {"sudo", "command", "time", "nohup", "exec", "builtin", "then", "do", "\\"}
def primary_util(bash):
    """Best-effort primary command of a snippet (skips sudo/env-assignments/env)."""
    first = ""
    for ln in bash.strip().splitlines():
        if ln.strip():
            first = ln.strip()
            break
    toks = first.split()
    i = 0
    while i < len(toks):
        t = toks[i]
        if t in _UTIL_SKIP or t == "env" or re.match(r"^[A-Za-z_][A-Za-z0-9_]*=", t):
            i += 1
            continue
        break
    if i >= len(toks):
        return "sh"
    u = os.path.basename(toks[i].strip("()`\"'"))
    return u or "sh"

# --- degeneracy: reject no-op transforms (find==replace, mv/cp X X) -----------
_SED_SUB = re.compile(r"s([/#|,@])(.*?)(?<!\\)\1(.*?)(?<!\\)\1")
def is_degenerate(bash):
    for m in _SED_SUB.finditer(bash):
        if m.group(2) and m.group(2) == m.group(3):
            return True
    m = re.match(r"^\s*(?:sudo\s+)?(?:mv|cp)\s+(?:-\S+\s+)*(\S+)\s+(\S+)\s*$", bash)
    if m and m.group(1) == m.group(2):
        return True
    return False

# --- answer equivalence: alternative correct commands for the same request ----
_QTOK = r"(?:'[^']*'|\"[^\"]*\"|[^\s|]+)"    # quoted-or-bare argument token
# flag clusters whose order is genuinely immaterial (all listed letters are
# no-argument flags for that tool), used to generate reordered/split variants.
_REORDER = {
    "ls":   set("laShtRd1Fr"),
    "grep":  set("rnilvcwoEFqxsH"),
    "sort":  set("nrufhbMdi"),
    "du":    set("sha"),
    "df":    set("hikTa"),
}
# single short flags with an unambiguous GNU long form, per tool.
_LONGOPT = {
    "grep": {"-i": "--ignore-case", "-v": "--invert-match", "-c": "--count",
             "-n": "--line-number", "-l": "--files-with-matches", "-r": "--recursive",
             "-w": "--word-regexp", "-o": "--only-matching"},
    "wc":   {"-l": "--lines", "-w": "--words", "-c": "--bytes", "-m": "--chars"},
    "mkdir":{"-p": "--parents"},
    "cp":   {"-r": "--recursive", "-R": "--recursive", "-f": "--force", "-v": "--verbose"},
    "rm":   {"-r": "--recursive", "-f": "--force", "-i": "--interactive"},
    "chmod":{"-R": "--recursive", "-v": "--verbose"},
    "chown":{"-R": "--recursive", "-v": "--verbose"},
    "df":   {"-h": "--human-readable", "-i": "--inodes", "-a": "--all"},
    "du":   {"-h": "--human-readable", "-s": "--summarize", "-a": "--all"},
    "free": {"-h": "--human", "-m": "--mega", "-g": "--giga", "-b": "--bytes",
             "-t": "--total", "-w": "--wide"},
    "uniq": {"-c": "--count", "-d": "--repeated", "-u": "--unique", "-i": "--ignore-case"},
    "head": {"-n": "--lines", "-c": "--bytes"},
    "tail": {"-n": "--lines", "-f": "--follow", "-c": "--bytes"},
    "sort": {"-n": "--numeric-sort", "-r": "--reverse", "-u": "--unique", "-h": "--human-numeric-sort"},
    "journalctl": {"-u": "--unit", "-f": "--follow", "-n": "--lines", "-k": "--dmesg",
                   "-b": "--boot", "-r": "--reverse"},
    "curl": {"-O": "--remote-name", "-I": "--head", "-s": "--silent", "-L": "--location",
             "-o": "--output", "-X": "--request", "-H": "--header", "-d": "--data"},
    "wget": {"-q": "--quiet", "-O": "--output-document", "-c": "--continue",
             "-r": "--recursive", "-np": "--no-parent"},
    "gzip": {"-k": "--keep", "-d": "--decompress", "-r": "--recursive", "-f": "--force"},
    "mv":   {"-f": "--force", "-i": "--interactive", "-n": "--no-clobber", "-v": "--verbose"},
    "pgrep":{"-c": "--count", "-a": "--list-full", "-n": "--newest", "-u": "--euid"},
    "pkill":{"-u": "--euid", "-f": "--full", "-9": "--signal 9"},
    "ps":   {},
    "systemctl": {},
}
# common numeric chmod modes with an exact symbolic equivalent
_CHMOD_SYM = {"644": "u=rw,go=r", "600": "u=rw,go=", "755": "u=rwx,go=rx",
              "700": "u=rwx,go=", "444": "a=r", "777": "a=rwx", "666": "a=rw",
              "640": "u=rw,g=r,o=", "664": "ug=rw,o=r"}
_SIG_NUM2NAME = {"9": "KILL", "15": "TERM", "1": "HUP", "2": "INT", "3": "QUIT", "6": "ABRT"}
_SIG_NAME2NUM = {v: k for k, v in _SIG_NUM2NAME.items()}

def equivalents(bash):
    """Return distinct, semantically-equivalent single-line alternatives to `bash`.
    Only fires on recognized command shapes; every alt is still re-checked by the
    caller (bash -n + argcheck + degeneracy + dedup) before being emitted."""
    if "\n" in bash:
        return []
    b = bash.strip()
    alts = []
    def add(x):
        if x and x != b and x not in alts:
            alts.append(x)

    # 1. flag-cluster reorder / split (order-immaterial no-arg flags)
    m = re.match(r"^(ls|grep|sort|du|df) -([a-zA-Z]{2,})(\s.*)?$", b)
    if m and all(ch in _REORDER[m.group(1)] for ch in m.group(2)):
        tool, cl, rest = m.group(1), m.group(2), m.group(3) or ""
        add(f"{tool} -{''.join(sorted(cl))}{rest}")
        add(f"{tool} -{cl[::-1]}{rest}")
        add(f"{tool} " + " ".join("-" + c for c in cl) + rest)

    # 2. long-form flag equivalent for the LEADING command ONLY. Keying off the
    #    first token but substituting anywhere in the pipeline used to leak a
    #    tool's map onto a DOWNSTREAM command's identical short flag -- e.g.
    #    `grep x f | tail -n 50` became `... | tail --line-number 50` (invalid,
    #    that's grep's -n long form, not tail's). Restrict the search+replace to
    #    the owning command's own segment; a flag mapped to None is never invented.
    seg = re.split(r"\s(?:\|\||\||&&|;)\s", b, 1)[0]     # leading command's segment
    _mp = _LONGOPT.get(seg.split(" ", 1)[0])
    if _mp:
        for short, lng in _mp.items():
            if lng is None:
                continue                                # no valid long form -> skip this axis
            mm = re.search(rf"(^|\s){re.escape(short)}(\s|$)", seg)
            if mm:
                add(seg[:mm.start()] + mm.group(1) + lng + mm.group(2)
                    + seg[mm.end():] + b[len(seg):])
                break

    # 3. specific pipeline / rewrite equivalences
    m = re.fullmatch(r"wc -l (\S+)", b)
    if m:
        f = m.group(1); add(f"wc -l < {f}"); add(f"cat {f} | wc -l")
    if re.fullmatch(r"cat (\S+) \| wc -l", b):
        add("wc -l < " + b.split()[1])
    m = re.fullmatch(rf"grep -c ({_QTOK}) (\S+)", b)
    if m:
        add(f"grep {m.group(1)} {m.group(2)} | wc -l")
    m = re.fullmatch(rf"grep ({_QTOK}) (\S+) \| wc -l", b)
    if m:
        add(f"grep -c {m.group(1)} {m.group(2)}")
    m = re.fullmatch(r"sort -u (\S+)", b)
    if m:
        add(f"sort {m.group(1)} | uniq")
    m = re.fullmatch(r"sort (\S+) \| uniq", b)
    if m:
        add(f"sort -u {m.group(1)}")
    m = re.fullmatch(r"head -n (\d+) (\S+)", b)
    if m:
        n, f = m.groups(); add(f"head -{n} {f}"); add(f"sed -n '1,{n}p' {f}")
    m = re.fullmatch(r"tail -n (\d+) (\S+)", b)
    if m:
        n, f = m.groups(); add(f"tail -{n} {f}")
    m = re.fullmatch(r"du -sh (\S+)", b)
    if m:
        f = m.group(1); add(f"du -hs {f}"); add(f"du -s -h {f}")
    # 4. find predicate reorder (order of -type/-name/-mtime/-size is immaterial)
    m = re.fullmatch(r"find (\S+) -type ([fd]) (-\S+ \S+|-empty)", b)
    if m:
        d, ty, pred = m.groups(); add(f"find {d} {pred} -type {ty}")
    # 5. tar: dashless classic form and flag reorder
    m = re.fullmatch(r"tar -(c|x|t)([zjJ])f (\S+)(.*)", b)
    if m:
        op, comp, arch, rest = m.groups()
        add(f"tar {op}{comp}f {arch}{rest}")
        add(f"tar -{comp}{op}f {arch}{rest}")
    # 6. cat -n <-> nl -ba ; cat -A <-> cat -vET
    m = re.fullmatch(r"cat -n (\S+)", b)
    if m:
        add(f"nl -ba {m.group(1)}")
    m = re.fullmatch(r"cat -A (\S+)", b)
    if m:
        add(f"cat -vET {m.group(1)}")
    # 6b. more single-command families
    m = re.fullmatch(r"date (\+\S+)", b)           # date format quoting
    if m:
        add(f'date "{m.group(1)}"')
    m = re.fullmatch(r'date "(\+[^"]+)"', b)
    if m:
        add(f"date {m.group(1)}")
    m = re.fullmatch(r"stat -c ('[^']*'|\"[^\"]*\"|\S+) (\S+)", b)   # stat -c <-> --format
    if m:
        add(f"stat --format={m.group(1)} {m.group(2)}")
        add(f"stat --printf={m.group(1)} {m.group(2)}")
    m = re.fullmatch(r"cut -d(\S) -f(\S+) (\S+)", b)                 # cut short <-> long
    if m:
        d, f, fn = m.groups(); add(f"cut --delimiter='{d}' --fields={f} {fn}")
    m = re.fullmatch(r"tr 'a-z' 'A-Z'( < \S+)?", b)                 # tr ranges <-> POSIX classes
    if m:
        add("tr '[:lower:]' '[:upper:]'" + (m.group(1) or ""))
    m = re.fullmatch(r"tr 'A-Z' 'a-z'( < \S+)?", b)
    if m:
        add("tr '[:upper:]' '[:lower:]'" + (m.group(1) or ""))
    m = re.fullmatch(r"ln -s (\S+) (\S+)", b)                        # ln -s <-> --symbolic
    if m:
        add(f"ln --symbolic {m.group(1)} {m.group(2)}")
    m = re.fullmatch(r"sort -k(\S+) -n (\S+)", b)                    # sort flag reorder w/ -k
    if m:
        add(f"sort -n -k{m.group(1)} {m.group(2)}")
    m = re.fullmatch(r"kill -(\S+) (\d+)", b)                        # signal number <-> name
    if m:
        sig, pid = m.groups()
        if sig in _SIG_NUM2NAME:
            add(f"kill -{_SIG_NUM2NAME[sig]} {pid}"); add(f"kill -s {_SIG_NUM2NAME[sig]} {pid}")
        elif sig in _SIG_NAME2NUM:
            add(f"kill -{_SIG_NAME2NUM[sig]} {pid}"); add(f"kill -s {sig} {pid}")
    m = re.fullmatch(r"pkill -9 (\S+)", b)
    if m:
        add(f"pkill -KILL {m.group(1)}")
    m = re.fullmatch(r"chmod (\d{3}) (\S+)", b)                      # numeric <-> symbolic
    if m and m.group(1) in _CHMOD_SYM:
        add(f"chmod {_CHMOD_SYM[m.group(1)]} {m.group(2)}")
    # 7. small fixed synonyms
    if b == "whoami":
        add("id -un"); add('echo "$USER"')
    if b in ("ip route", "ip route show", "ip r"):
        for x in ("ip route show", "ip route", "ip r"):
            add(x)
    if b in ("ip addr", "ip addr show", "ip a"):
        for x in ("ip addr show", "ip addr", "ip a"):
            add(x)
    if b in ("id -u",):
        add("id --user")
    return alts

# --- seed ingestion (tldr-pages descriptions + local nl2bash/NL2SH) -----------
SEED_CACHE = os.path.join(SEEDS_DIR, "_seedcache.json")
TLDR_RAW   = os.path.join(SEEDS_DIR, "_tldr_raw.json")   # cached (desc,cmd) pairs pre-filter
TLDR_ZIP_URL = "https://codeload.github.com/tldr-pages/tldr/zip/refs/heads/main"

# Only keep tldr seeds whose PRIMARY command is a coreutils / text / file / network
# / sysadmin tool that fills CLEANLY from a single typed placeholder. Subcommand
# multiplexers (git, docker, npm, cargo, apt, python, ...) and obscure third-party
# CLIs (bq, fastlane, ffprobe, VBoxManage, ...) are excluded: their tldr examples
# fill into nonsense, and the recipe engine already covers git/apt/etc. directly.
SHELL_UTILS = set("""
ls cat tac head tail grep egrep fgrep zgrep sed awk cut tr sort uniq wc find xargs tee
cp mv rm rmdir mkdir touch ln chmod chown chgrp stat file du df tar gzip gunzip zcat zip
unzip bzip2 bunzip2 xz unxz readlink realpath basename dirname
curl wget ssh scp sftp rsync ping ping6 dig host nslookup nc ncat traceroute mtr
ps top htop kill pkill pgrep killall nice renice jobs nohup timeout watch
journalctl dmesg uptime free vmstat iostat
mpstat sar pidstat lsof ss netstat ifconfig hostname uname arch
who w whoami id groups last lastlog users tty getent
date cal sleep echo printf seq yes env printenv which whereis type
mount umount lsblk blkid findmnt sync swapon lscpu lspci lsusb lsmod
diff patch cmp comm join paste split csplit nl fold fmt expand unexpand column pr
od xxd hexdump strings rev shuf tsort base64 base32 md5sum sha1sum sha256sum sha512sum
cksum b2sum crontab
jq tree ncdu fd rg bat pv
ssh-keygen ssh-copy-id gpg openssl sqlite3 redis-cli
""".split())

def _http_get(url, timeout=60):
    req = urllib.request.Request(url, headers={"User-Agent": "bash-ds-seed/2"})
    with urllib.request.urlopen(req, timeout=timeout) as r:
        return r.read()

_PH = re.compile(r"\{\{(.*?)\}\}")
_GENERIC_TOK = ["myapp", "example", "project", "backend", "worker", "report",
                "item", "target", "payload", "job", "task", "widget"]
# structural placeholders that can't be auto-filled with a noun (subcommands,
# options, free-form arg lists): any template containing one is rejected outright.
_PH_BLOCK = re.compile(r"\b(sub-?commands?|commands?|options?|args?|arguments?|"
                       r"flags?|parameters?|librar(y|ies)|modules?|executables?|"
                       r"binar(y|ies)|programs?|scripts?|expressions?|code)\b")
def _classify_ph(inner):
    """Classify a tldr {{placeholder}} -> (value, kind).
      kind 'mapped'  : filled from a typed pool (file/dir/host/user/...).
      kind 'generic' : a plausible generic token (only one allowed per command).
      kind 'block'   : structural (subcommand/option/...) -> reject the template."""
    t = inner.strip().lower()
    if _PH_BLOCK.search(t):
        return None, "block"
    if re.fullmatch(r"[+-]?\d+", t):
        return inner.strip(), "mapped"
    if "regex" in t or "pattern" in t or "search" in t:
        return R(PATTERNS), "mapped"
    if ("user" in t and "name" in t) or t in ("user", "username", "owner"):
        return R(USERS), "mapped"
    if "group" in t:
        return R(GROUPS), "mapped"
    if "service" in t or "unit" in t or "daemon" in t:
        return R(SERVICES), "mapped"
    if "process" in t or "container" in t:
        return R(PROCS), "mapped"
    if "port" in t:
        return str(R(PORTS)), "mapped"
    if "package" in t:
        return R(PKGS), "mapped"
    if "branch" in t:
        return R(BRANCHES), "mapped"
    if "host" in t or "domain" in t or "url" in t or "ip" in t or "address" in t or "server" in t:
        return R(HOSTS), "mapped"
    if any(k in t for k in ("count", "number", "size", "length", "width",
                            "seconds", "minutes", "lines", "depth", "level", "num")):
        return str(R([1, 2, 3, 5, 10, 20, 50, 100])), "mapped"
    if any(k in t for k in ("uuid", "hash", "sha", "commit", "token")):
        return R(["a1b2c3d", "e4f5a6b", "9c8d7e6", "abc1234"]), "mapped"
    if "email" in t:
        return R(["alice@example.com", "bob@example.org", "carol@example.net"]), "mapped"
    if "date" in t:
        return R(["2026-01-15", "2026-03-01", "2025-12-31"]), "mapped"
    if "database" in t or t in ("db", "table", "schema"):
        return R(["appdb", "users", "orders", "metrics"]), "mapped"
    if "dir" in t or "folder" in t or t == "path":
        return R(SDIRS), "mapped"
    if "file" in t or "path/to" in t or "filename" in t or "/" in inner or "." in inner:
        return R(FILES), "mapped"
    return R(_GENERIC_TOK), "generic"

def _subst_tldr(cmd):
    """Fill a tldr command's placeholders. Returns None (reject) if it contains a
    structural placeholder or more than one generic placeholder."""
    state = {"generic": 0, "block": False}
    def repl(m):
        val, kind = _classify_ph(m.group(1))
        if kind == "block":
            state["block"] = True
            return "\x00"
        if kind == "generic":
            state["generic"] += 1
        return val if val is not None else ""
    out = _PH.sub(repl, cmd)
    if state["block"] or state["generic"] > 0:      # only fully-typed templates survive
        return None
    if "{{" in out or "}}" in out or "path/to" in out or "\x00" in out:
        return None
    return out

def _parse_tldr_text(text):
    """Yield (description, command_template) pairs from one tldr .md page."""
    pairs = []; desc = None
    for ln in text.splitlines():
        s = ln.strip()
        if s.startswith("- "):
            desc = s[2:].strip().rstrip(":").strip()
        elif desc and len(s) > 2 and s.startswith("`") and s.endswith("`"):
            pairs.append((desc, s[1:-1])); desc = None
    return pairs

def _seeds_from_tldr_zip(data):
    pairs = []
    zf = zipfile.ZipFile(io.BytesIO(data))
    for name in zf.namelist():
        if not name.endswith(".md") or "/pages/" not in name:
            continue                                   # english pages/ only (localized are pages.xx)
        top = name.split("/pages/", 1)[1].split("/", 1)[0]
        if top not in ("common", "linux"):
            continue
        try:
            pairs += _parse_tldr_text(zf.read(name).decode("utf-8", "ignore"))
        except Exception:
            continue
    return pairs

_FRANKEN = re.compile(r"(?<![\w./=$-])([a-z]+_[a-z][a-z_]*)\b(?!\.\w)")
def _sample_fill(cmd, source):
    """Produce ONE concrete instantiation of a (possibly templated) command, or
    None if it can't be made clean/safe. Random each call -> fresh nouns."""
    bash = _subst_tldr(cmd) if source == "tldr" else cmd
    if bash is None or "{{" in bash or "path/to" in bash or len(bash) > 400:
        return None
    if _is_destructive(bash) or is_degenerate(bash):
        return None
    # reject leftover Frankenstein debris: a bare multi-word snake_case token that
    # is NOT a long flag (--foo_bar), a filename (foo_bar.ext), or a shell variable.
    for m in _FRANKEN.finditer(bash):
        tok = m.group(1)
        if f"${tok}" not in bash and f"${{{tok}}}" not in bash:
            return None
    return bash

def _mk_seed(desc, cmd, source):
    """Build a seed TEMPLATE (placeholders kept) validated via one sample fill.
    Placeholders are filled fresh at draw time so one template -> many pairs."""
    cmd = cmd.strip()
    if not cmd or not desc or len(desc) < 6 or len(desc) > 200 or len(cmd) > 400:
        return None
    if source != "tldr" and "{{" in cmd:
        return None
    util = primary_util(cmd)
    if not re.fullmatch(r"[A-Za-z0-9_.\-]+", util):
        return None
    if source == "tldr" and util not in SHELL_UTILS:
        return None                    # drop obscure third-party CLIs
    if _is_destructive(cmd):
        return None
    nl = desc[0].upper() + desc[1:]
    if not nl.endswith((".", "?", "!")):
        nl += "."
    sample = _sample_fill(cmd, source)          # validate one concrete instantiation
    if sample is None or arg_mismatch(nl, sample):
        return None
    return {"nl": nl, "cmd": cmd, "category": categorize(sample),
            "utility": util, "source": source}

def _fill_seed(tpl):
    """Instantiate a seed template with fresh nouns -> (nl, bash, util, cat) or None."""
    bash = _sample_fill(tpl["cmd"], tpl["source"])
    if bash is None or arg_mismatch(tpl["nl"], bash):
        return None
    return tpl["nl"], bash, tpl["utility"], tpl["category"]

def _load_local_nl2bash():
    pairs = []
    nlf, cmf = os.path.join(SEEDS_DIR, "all.nl"), os.path.join(SEEDS_DIR, "all.cm")
    if os.path.exists(nlf) and os.path.exists(cmf):
        with open(nlf, encoding="utf-8", errors="ignore") as a, \
             open(cmf, encoding="utf-8", errors="ignore") as b:
            for nl, cm in zip(a, b):
                pairs.append((nl.strip(), cm.strip()))
    for tsv in glob.glob(os.path.join(SEEDS_DIR, "*.tsv")):
        with open(tsv, encoding="utf-8", errors="ignore") as fh:
            for line in fh:
                if "\t" in line:
                    nl, cm = line.rstrip("\n").split("\t", 1)
                    pairs.append((nl.strip(), cm.strip()))
    return pairs

def _seed_syntax_filter(items, verbose):
    out = []
    for k in range(0, len(items), 500):
        chunk = items[k:k + 500]
        samples = [_sample_fill(c["cmd"], c["source"]) or "true" for c in chunk]
        for c, ok in zip(chunk, bash_n_batch(samples)):
            if ok:
                out.append(c)
    if verbose:
        print(f"[seeds] syntax-valid after bash -n: {len(out)}/{len(items)}")
    return out

def _bucket_seeds(items):
    d = {"single": [], "pipeline": [], "script": []}
    for s in items:
        d[s.get("category") or categorize(s["bash"])].append(s)
    return d

def load_seeds(refresh=False, allow_net=True, refresh_net=False, verbose=True):
    """Return {category: [seed,...]}. Uses ./seeds/_seedcache.json when present;
    else builds from tldr-pages (cached raw download / local dir) + any local
    nl2bash/NL2SH files, then validates + caches. Never raises on network error.
      refresh      -> rebuild the filtered seed cache (reuses raw tldr if present)
      refresh_net  -> also re-download the raw tldr pages"""
    os.makedirs(SEEDS_DIR, exist_ok=True)
    if os.path.exists(SEED_CACHE) and not refresh and not refresh_net:
        try:
            with open(SEED_CACHE, encoding="utf-8") as fh:
                cached = json.load(fh)
            if verbose:
                print(f"[seeds] loaded {len(cached)} cached seed pairs from {SEED_CACHE}")
            return _bucket_seeds(cached)
        except Exception:
            pass
    tldr_pairs = []
    local_tldr = os.path.join(SEEDS_DIR, "tldr")
    if os.path.exists(TLDR_RAW) and not refresh_net:
        try:
            tldr_pairs = [tuple(x) for x in json.load(open(TLDR_RAW, encoding="utf-8"))]
            if verbose:
                print(f"[seeds] reusing {len(tldr_pairs)} raw tldr examples from cache")
        except Exception:
            tldr_pairs = []
    if not tldr_pairs and os.path.isdir(local_tldr):
        for root, _, files in os.walk(local_tldr):
            for fn in files:
                if fn.endswith(".md"):
                    try:
                        tldr_pairs += _parse_tldr_text(
                            open(os.path.join(root, fn), encoding="utf-8", errors="ignore").read())
                    except Exception:
                        pass
        if verbose:
            print(f"[seeds] parsed {len(tldr_pairs)} tldr examples from local {local_tldr}")
    if not tldr_pairs and allow_net:
        try:
            if verbose:
                print("[seeds] downloading tldr-pages (network) ...")
            tldr_pairs = _seeds_from_tldr_zip(_http_get(TLDR_ZIP_URL))
            if verbose:
                print(f"[seeds] parsed {len(tldr_pairs)} tldr examples from network")
            try:
                json.dump(tldr_pairs, open(TLDR_RAW, "w", encoding="utf-8"), ensure_ascii=False)
            except Exception:
                pass
        except Exception as e:
            if verbose:
                print(f"[seeds] tldr fetch failed ({e}); continuing without tldr")
    elif not tldr_pairs and verbose:
        print("[seeds] no raw/local tldr and network disabled")
    seeds = []
    for desc, cmd in tldr_pairs:
        s = _mk_seed(desc, cmd, "tldr")
        if s:
            seeds.append(s)
    n2b = _load_local_nl2bash()
    if n2b and verbose:
        print(f"[seeds] parsed {len(n2b)} local nl2bash/NL2SH pairs")
    for nl, cm in n2b:
        s = _mk_seed(nl, cm, "nl2sh")
        if s:
            seeds.append(s)
    seen, uniq = set(), []
    for s in seeds:
        k = (s["nl"], s["cmd"])
        if k not in seen:
            seen.add(k); uniq.append(s)
    if verbose:
        print(f"[seeds] {len(uniq)} unique candidate templates (pre-syntax)")
    uniq = _seed_syntax_filter(uniq, verbose)
    try:
        with open(SEED_CACHE, "w", encoding="utf-8") as fh:
            json.dump(uniq, fh, ensure_ascii=False)
    except Exception:
        pass
    if verbose:
        by = {}
        for s in uniq:
            by[s["source"]] = by.get(s["source"], 0) + 1
        print(f"[seeds] kept {len(uniq)} valid seed pairs -> cached ({by})")
    return _bucket_seeds(uniq)

# --------------------------------------------------------------------------
# engine
# --------------------------------------------------------------------------
def load_state():
    counts_cat = {"single":0,"pipeline":0,"script":0}   # ROW level (drives 40/35/25)
    counts_cat_base = {"single":0,"pipeline":0,"script":0}  # REQUEST level (drives seed deficit)
    counts_util = {}       # REQUEST level (one per variant_group) -> drives the 4% cap
    counts_util_rows = {}  # ROW level -> reporting only (may exceed 4% via variants)
    seen = set()
    seen_groups = set()
    total = 0
    # source stats (seed vs template vs variant) are a generation-time report;
    # they can't be recomputed from the file's schema, so carry them forward
    # from the previous progress snapshot (best-effort, resumable).
    src = {"seed_groups":0,"template_groups":0,"variant_rows":0}
    if os.path.exists(PROG):
        try:
            prev = json.load(open(PROG, encoding="utf-8"))
            for k in src:
                src[k] = prev.get(k, src[k])
        except Exception:
            pass
    if os.path.exists(OUT):
        with open(OUT, encoding="utf-8") as fh:
            for line in fh:
                line = line.strip()
                if not line:
                    continue
                try:
                    o = json.loads(line)
                except json.JSONDecodeError:
                    continue
                nl, bash = row_nl_bash(o)
                total += 1
                u = o["utility"]
                counts_cat[o["category"]] = counts_cat.get(o["category"],0)+1
                counts_util_rows[u] = counts_util_rows.get(u,0)+1
                # count each request (variant_group) once toward the cap tally
                grp = o.get("variant_group")
                key = grp if grp is not None else ("__solo__", total)
                if key not in seen_groups:
                    seen_groups.add(key)
                    counts_util[u] = counts_util.get(u,0)+1
                    counts_cat_base[o["category"]] = counts_cat_base.get(o["category"],0)+1
                h = hashlib.sha1((nl+"\x00"+bash).encode()).hexdigest()
                seen.add(h)
    counts_util_var = {u: counts_util_rows.get(u,0)-counts_util.get(u,0) for u in counts_util_rows}
    return {"total":total,"cat":counts_cat,"cat_base":counts_cat_base,"util":counts_util,
            "util_rows":counts_util_rows,"util_var":counts_util_var,"seen":seen,"src":src}

def row_nl_bash(o):
    """Extract (nl, bash) from a dataset row in either schema."""
    if "messages" in o:
        nl = next(m["content"] for m in o["messages"] if m["role"] == "user")
        bash = next(m["content"] for m in o["messages"] if m["role"] == "assistant")
        return nl, bash
    return o["nl"], o["bash"]

def save_progress(state):
    src = state.get("src", {})
    sg, tg = src.get("seed_groups",0), src.get("template_groups",0)
    grp = sg + tg
    snap = {
        "total": state["total"],
        "target_total": TARGET_TOTAL,
        "category_target": CAT_TARGET,
        "category_counts": state["cat"],
        "util_cap": UTIL_CAP,
        # v2 provenance: "requests" = base pairs (one per variant_group); variant
        # rows are the extra equivalent answers attached to some of those groups.
        "seed_groups": sg,
        "template_groups": tg,
        "variant_rows": src.get("variant_rows",0),
        "seed_fraction_of_requests": round(sg/grp, 4) if grp else 0,
        "template_fraction_of_requests": round(tg/grp, 4) if grp else 0,
        "seed_frac_setting": SEED_FRAC,
        "variant_frac_setting": VARIANT_FRAC,
        # cap is enforced on requests; row share may drift slightly above 4%.
        "requests_total": grp,
        "max_util_request_share": round(max(state["util"].values())/grp, 4) if grp and state["util"] else 0,
        "max_util_row_share": round(max(state.get("util_rows",{}).values())/state["total"], 4)
                              if state["total"] and state.get("util_rows") else 0,
        "util_counts_requests": dict(sorted(state["util"].items(), key=lambda x:-x[1])),
        "util_counts_rows": dict(sorted(state.get("util_rows",{}).items(), key=lambda x:-x[1])),
    }
    with open(PROG,"w",encoding="utf-8") as fh:
        json.dump(snap, fh, indent=2)

def recipes_by_cat():
    d = {"single":[],"pipeline":[],"script":[]}
    for r in RECIPES:
        d[r["category"]].append(r)
    return d
RBC = recipes_by_cat()

def choose_category(state):
    rem = {c: CAT_TARGET[c]-state["cat"].get(c,0) for c in CAT_TARGET}
    rem = {c:v for c,v in rem.items() if v>0}
    if not rem:
        return None
    cats = list(rem); weights = list(rem.values())
    return random.choices(cats, weights=weights, k=1)[0]

def choose_recipe(cat, state):
    pool = [r for r in RBC[cat] if state["util"].get(r["utility"],0) < UTIL_CAP]
    if not pool:
        return None
    return random.choices(pool, weights=[r["weight"] for r in pool], k=1)[0]

def choose_deficit_recipe(merged, cat_now):
    """Bias generation toward utilities still below their MIN_UTIL floor.
    Returns (recipe, category) or None. Only picks recipes whose category
    still has quota left, so it never violates category targets."""
    deficits = {u: MIN_UTIL[u]-merged.get(u,0)
                for u in MIN_UTIL if merged.get(u,0) < MIN_UTIL[u]}
    if not deficits:
        return None
    u = random.choices(list(deficits), weights=list(deficits.values()), k=1)[0]
    recs = [r for r in RECIPES
            if r["utility"] == u
            and cat_now.get(r["category"],0) < CAT_TARGET[r["category"]]]
    if not recs:
        return None
    r = random.choices(recs, weights=[rr["weight"] for rr in recs], k=1)[0]
    return r, r["category"]

def bash_n_batch(snippets):
    """Return list of bools (valid?) for each snippet. Uses combined function-wrap;
    falls back to per-snippet on failure."""
    os.makedirs(VALID_DIR, exist_ok=True)
    combined = os.path.join(VALID_DIR, "combined.sh")
    with open(combined,"w",encoding="utf-8",newline="\n") as fh:
        for i,s in enumerate(snippets):
            fh.write(f"__v{i}() {{\n{s}\n}}\n")
    r = subprocess.run([BASH,"-n",combined], capture_output=True, text=True)
    if r.returncode == 0:
        return [True]*len(snippets)
    # fallback: check each individually
    res = []
    for i,s in enumerate(snippets):
        p = os.path.join(VALID_DIR, f"s{i}.sh")
        with open(p,"w",encoding="utf-8",newline="\n") as fh:
            fh.write(s+"\n")
        rr = subprocess.run([BASH,"-n",p], capture_output=True, text=True)
        res.append(rr.returncode==0)
    return res

def _seed_pick(cat, merged, seen):
    """Pick a seed template of category `cat` (utility under cap, template not over
    its reuse cap) and instantiate it with fresh nouns into a NOT-yet-seen pair, so
    reuse budget is spent only on genuinely new rows (not dedup collisions).
    Returns a base dict {nl,bash,utility,category,source} or None."""
    pool = SEEDS.get(cat) or []
    if not pool:
        return None
    # scan a slice, least-used templates first, so reuse spreads evenly and high-
    # cardinality templates reach their reuse cap (maximizes distinct seed pairs).
    slice_ = random.sample(pool, min(len(pool), 160))
    slice_.sort(key=lambda t: _SEED_USE.get(id(t), 0))
    for tpl in slice_:
        if merged.get(tpl["utility"], 0) >= UTIL_CAP:
            continue
        if _SEED_USE.get(id(tpl), 0) >= SEED_TEMPLATE_CAP:
            continue
        templated = "{{" in tpl["cmd"]
        for _ in range(5):                     # find a fill not already in the dataset
            f = _fill_seed(tpl)
            if f is None:
                break
            nl, bash, util, c2 = f
            h = hashlib.sha1((nl + "\x00" + bash).encode()).hexdigest()
            if h in seen:
                if not templated:
                    break                      # placeholder-free -> no new pairs possible
                continue
            _SEED_USE[id(tpl)] = _SEED_USE.get(id(tpl), 0) + 1
            return {"nl": nl, "bash": bash, "utility": util, "category": c2, "source": "seed"}
    return None

def _draw_base(state, merged, cat_now, no_floor=False, no_script=False, prefer_seed=False):
    """Select and build one base (request, command) honoring floors / seed-frac /
    cap / degeneracy / argument-fidelity / dedup. Returns a dict, None (retry),
    or the sentinel "STOP" when all category quotas are full.
    no_floor/no_script steer variant-seeking draws toward single/pipeline commands;
    prefer_seed forces the real-phrasing (seed) pass so seeds claim util headroom
    before the recipes saturate the shared coreutils caps."""
    rec = cat = seed = None
    # Floor pass: 60% of the time, preferentially fill under-floor utilities
    # (always via templates). Runs even under prefer_seed -- the system-util floors
    # are a hard requirement and use different utilities than the seed pool, so they
    # don't meaningfully compete with real-phrasing seeds.
    if not no_floor and random.random() < 0.6:
        dr = choose_deficit_recipe(merged, cat_now)
        if dr is not None:
            rec, cat = dr
    if rec is None:
        if no_script:
            rem = {c: CAT_TARGET[c]-cat_now.get(c,0) for c in ("single","pipeline")}
            rem = {c:v for c,v in rem.items() if v>0}
            cat = random.choices(list(rem), weights=list(rem.values()), k=1)[0] if rem else None
        else:
            cat = choose_category({"cat": cat_now})
        if cat is None:
            return "STOP" if not no_script else None
        # real-phrasing pass: draw this request from the seed corpus
        if SEEDS.get(cat) and (prefer_seed or random.random() < SEED_FRAC):
            seed = _seed_pick(cat, merged, state["seen"])
        if seed is None:
            rec = choose_recipe(cat, {"util": merged})
            if rec is None:
                return None
    if seed is not None:
        nl, bash, util, source, cat = seed["nl"], seed["bash"], seed["utility"], "seed", seed["category"]
    else:
        if rec is None:               # unreachable in practice; guards the type
            return None
        res = rec["fn"]()
        if len(res) == 3:
            nl, bash, util = res              # recipe supplied a dynamic utility
        else:
            nl, bash = res
            util = rec["utility"]
        nl = diversify_nl(nl)                 # break up the dominant script opening
        cat = rec["category"]
        source = "template"
    if merged.get(util, 0) >= UTIL_CAP:       # real per-utility cap
        return None
    if is_degenerate(bash):                   # no-op transforms (sed s/x/x/, mv f f)
        return None
    # HARD GATE: command must reference the concrete nouns named in the request.
    if arg_mismatch(nl, bash):
        return None
    h = hashlib.sha1((nl + "\x00" + bash).encode()).hexdigest()
    if h in state["seen"]:
        return None
    return {"nl": nl, "bash": bash, "util": util, "cat": cat, "source": source, "h": h}

def generate_batch(state, batch_size):
    cand = []
    provisional_util = {}    # request level (base only) -> 4% cap
    provisional_cat = {}     # row level (base+variants) -> 40/35/25
    provisional_var = {}     # variant rows per utility  -> capped at ROW_CAP-UTIL_CAP
    prov_cat_base = {}       # request level per category -> seed-deficit denominator
    prov_seed = 0            # seed base requests this batch -> seed-deficit numerator
    var_budget = max(0, ROW_CAP - UTIL_CAP)   # variants allowed per utility (batch-independent)
    attempts = 0
    max_attempts = batch_size*80
    while len(cand) < batch_size and attempts < max_attempts:
        attempts += 1
        # merged util + category views (include provisional within this batch)
        merged = dict(state["util"])
        for u,v in provisional_util.items():
            merged[u] = merged.get(u,0)+v
        cat_now = {c:state["cat"].get(c,0)+provisional_cat.get(c,0) for c in CAT_TARGET}
        # Seed deficit: prefer real-phrasing seeds until they reach SEED_FRAC of the
        # TARGET seedable (single+pipeline) requests, so they claim util headroom
        # before the HIGHCAP recipes saturate the shared coreutils caps. The
        # denominator is the TARGET (not seeded-so-far) -- otherwise the ratio sits
        # near 1.0 early, flips the preference off, and recipes cap the utils first.
        # Once the template pool is drained this simply falls back to recipes.
        seedable_target = CAT_TARGET["single"] + CAT_TARGET["pipeline"]
        seed_have = state.get("src",{}).get("seed_groups",0) + prov_seed
        prefer_seed = seed_have < SEED_FRAC * seedable_target
        # Decide up front whether this request should carry alternative answers.
        # If so, spend a few draws seeking a base that actually HAS equivalents so
        # the variant budget lands on ~VARIANT_FRAC of requests (mild, benign bias
        # toward the common utilities that genuinely have multiple correct forms).
        want_variant = random.random() < VARIANT_FRAC
        base = fallback = None
        stop = False
        for _ in range(8 if want_variant else 1):
            # Don't route variant-seeking draws to seeds: they retry looking for a
            # base WITH equivalents (recipe territory), and each discarded seed hit
            # would burn that template's reuse budget. Seeds flow via non-variant draws.
            b = _draw_base(state, merged, cat_now,
                           no_floor=want_variant, no_script=want_variant,
                           prefer_seed=(prefer_seed and not want_variant))
            if b == "STOP":
                stop = True; break
            if b is None:
                continue
            if not want_variant:
                base = b; break
            if equivalents(b["bash"]):
                base = b; break
            fallback = fallback or b
        if stop:
            break
        base = base or fallback
        if base is None:
            # variant-seeking draw found nothing eligible; fall back to a plain draw
            b = _draw_base(state, merged, cat_now, prefer_seed=prefer_seed)
            if b == "STOP":
                break
            if b is None:
                continue
            base = b
        nl, bash, util, cat, h = base["nl"], base["bash"], base["util"], base["cat"], base["h"]
        state["seen"].add(h)
        grp = secrets.token_hex(8)            # variant_group id (solo or shared)
        rows = [{"nl":nl,"bash":bash,"category":cat,"utility":util,
                 "group":grp,"_h":h,"_src":base["source"]}]
        provisional_util[util] = provisional_util.get(util,0)+1
        provisional_cat[cat] = provisional_cat.get(cat,0)+1
        prov_cat_base[cat] = prov_cat_base.get(cat,0)+1
        if base["source"] == "seed":
            prov_seed += 1
        # ---- answer diversity: attach 1-2 equivalent solutions ------------
        # Variant rows are EXEMPT from the 4% request cap (the cap is enforced on
        # requests, not rows) but still (a) consume row-level category budget so
        # the delivered 40/35/25 split is by rows, and (b) are capped per utility
        # at ROW_CAP-UTIL_CAP so base(<=UTIL_CAP)+variants stays <= ROW_CAP (<=5% rows).
        if want_variant:
            for alt in equivalents(bash):
                if len(rows) >= 3:
                    break
                cur_cat = state["cat"].get(cat,0)+provisional_cat.get(cat,0)
                cur_var = state.get("util_var",{}).get(util,0)+provisional_var.get(util,0)
                if cur_cat >= CAT_TARGET[cat] or cur_var >= var_budget:
                    break
                if is_degenerate(alt) or arg_mismatch(nl, alt):
                    continue
                ah = hashlib.sha1((nl+"\x00"+alt).encode()).hexdigest()
                if ah in state["seen"]:
                    continue
                state["seen"].add(ah)
                rows.append({"nl":nl,"bash":alt,"category":cat,"utility":util,
                             "group":grp,"_h":ah,"_src":"variant"})
                provisional_cat[cat] = provisional_cat.get(cat,0)+1   # row-level
                provisional_var[util] = provisional_var.get(util,0)+1
        cand.extend(rows)

    if not cand:
        return 0, 0
    # syntax check
    valid = bash_n_batch([c["bash"] for c in cand])
    kept = []
    dropped = 0
    for c,ok in zip(cand, valid):
        if ok:
            kept.append(c)
        else:
            dropped += 1
            state["seen"].discard(c["_h"])
    # append to disk in chat-messages ("final") form, with metadata + variant_group
    # kept alongside for quota tracking / resume (trainers just read "messages").
    src = state.setdefault("src", {"seed_groups":0,"template_groups":0,"variant_rows":0})
    with open(OUT,"a",encoding="utf-8") as fh:
        for c in kept:
            row = {"messages":[
                       {"role":"system","content":R(SYSTEM_PROMPTS)},
                       {"role":"user","content":c["nl"]},
                       {"role":"assistant","content":c["bash"]},
                   ],
                   "category":c["category"],"utility":c["utility"],
                   "variant_group":c["group"]}
            fh.write(json.dumps(row, ensure_ascii=False)+"\n")
            state["total"] += 1
            state["cat"][c["category"]] = state["cat"].get(c["category"],0)+1
            ur = state.setdefault("util_rows", {})
            ur[c["utility"]] = ur.get(c["utility"],0)+1              # row level (report)
            if c["_src"] == "variant":
                src["variant_rows"] += 1
                uv = state.setdefault("util_var", {})
                uv[c["utility"]] = uv.get(c["utility"],0)+1          # cumulative variants
            else:                                                    # base = one request
                state["util"][c["utility"]] = state["util"].get(c["utility"],0)+1
                cbs = state.setdefault("cat_base", {})
                cbs[c["category"]] = cbs.get(c["category"],0)+1
                if c["_src"] == "seed":
                    src["seed_groups"] += 1
                else:
                    src["template_groups"] += 1
    save_progress(state)
    return len(kept), dropped

def cmd_status(state):
    print(f"total rows written: {state['total']} / {TARGET_TOTAL}")
    for c in CAT_TARGET:
        print(f"  {c:9s}: {state['cat'].get(c,0):6d} / {CAT_TARGET[c]}")
    req_total = sum(state['util'].values())
    print(f"requests (variant_groups): {req_total}  |  distinct utilities: {len(state['util'])}"
          f"  |  cap per utility (on requests): {UTIL_CAP}")
    over = [(u,n) for u,n in state['util'].items() if n>UTIL_CAP]
    if over: print("  OVER REQUEST CAP:", over)
    top = sorted(state['util'].items(), key=lambda x:-x[1])[:12]
    print("  top utilities (requests):", ", ".join(f"{u}={n}" for u,n in top))
    ur = state.get("util_rows", {})
    if ur and req_total:
        mu, mn = max(ur.items(), key=lambda x:x[1])
        print(f"  max util REQUEST share: {max(state['util'].values())/req_total*100:.2f}%  |  "
              f"max util ROW share: {mu}={mn/state['total']*100:.2f}%")
    floors = {u: (state['util'].get(u,0), m) for u,m in MIN_UTIL.items()}
    unmet = {u:v for u,v in floors.items() if v[0] < v[1]}
    print("  info-util floors:", ", ".join(f"{u}={v[0]}/{v[1]}" for u,v in sorted(floors.items())))
    print("  floors unmet:", unmet if unmet else "NONE")

def cmd_plan(state):
    print(f"TARGET {TARGET_TOTAL} | util cap {UTIL_CAP} ({UTIL_CAP/TARGET_TOTAL*100:.0f}%)")
    print("category   target   have   short")
    for c in CAT_TARGET:
        have = state["cat"].get(c,0)
        print(f"  {c:9s} {CAT_TARGET[c]:7d} {have:6d} {max(0,CAT_TARGET[c]-have):6d}")
    print(f"recipes registered: {len(RECIPES)} "
          f"(single={len(RBC['single'])}, pipeline={len(RBC['pipeline'])}, script={len(RBC['script'])})")
    utils = sorted({r['utility'] for r in RECIPES})
    print(f"distinct utilities in recipe set: {len(utils)}")
    print(" ", ", ".join(utils))

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("cmd", choices=["status","plan","run","validate-all","seeds"])
    ap.add_argument("--batch", type=int, default=500)
    ap.add_argument("--batches", type=int, default=1)
    ap.add_argument("--target", type=int, default=None,
                    help="override total (rescales category targets, 4%% cap, and floors)")
    ap.add_argument("--out", default=OUT, help="output JSONL (progress file derived from it)")
    ap.add_argument("--seed-frac", type=float, default=SEED_FRAC,
                    help="fraction of non-floor requests drawn from real seeds")
    ap.add_argument("--variant-frac", type=float, default=VARIANT_FRAC,
                    help="fraction of requests that get extra equivalent-answer rows")
    ap.add_argument("--row-cap-pct", type=float, default=ROW_CAP_PCT,
                    help="max total-row share per utility (base+variants); trades off variant coverage")
    ap.add_argument("--seed-reuse", type=int, default=SEED_TEMPLATE_CAP,
                    help="max reuse of one tldr template (higher = more real-phrased rows, less NL variety)")
    ap.add_argument("--no-net", action="store_true", help="never download seeds; local only")
    ap.add_argument("--refresh-seeds", action="store_true", help="rebuild filtered seed cache (reuse raw tldr)")
    ap.add_argument("--refresh-net", action="store_true", help="re-download raw tldr pages, then rebuild")
    args = ap.parse_args()

    globals()["OUT"] = os.path.abspath(args.out)
    globals()["PROG"] = os.path.splitext(globals()["OUT"])[0] + ".progress.json"
    globals()["SEED_FRAC"] = args.seed_frac
    globals()["VARIANT_FRAC"] = args.variant_frac
    globals()["ROW_CAP_PCT"] = args.row_cap_pct
    globals()["SEED_TEMPLATE_CAP"] = args.seed_reuse
    t = args.target or TARGET_TOTAL
    if args.target:
        globals()["TARGET_TOTAL"] = t
        globals()["CAT_TARGET"] = {c: int(round(t*s)) for c, s in CAT_SHARE.items()}
        globals()["UTIL_CAP"] = max(1, int(t*0.04))
        scale = t / _BASE_TARGET
        globals()["MIN_UTIL"] = {u: max(1, int(round(v*scale)))
                                 for u, v in _BASE_MIN_UTIL.items()}
    globals()["ROW_CAP"] = max(globals()["UTIL_CAP"], int(t*ROW_CAP_PCT))

    if args.cmd == "seeds":
        s = load_seeds(refresh=args.refresh_seeds, allow_net=not args.no_net, refresh_net=args.refresh_net)
        print("seed pairs by category:")
        for c in ("single","pipeline","script"):
            print(f"  {c:9s}: {len(s[c])}")
        return

    state = load_state()

    if args.cmd == "status":
        cmd_status(state); return
    if args.cmd == "plan":
        cmd_plan(state); return
    if args.cmd == "validate-all":
        snippets=[];
        with open(OUT,encoding="utf-8") as fh:
            for line in fh:
                line=line.strip()
                if line: snippets.append(row_nl_bash(json.loads(line))[1])
        res = bash_n_batch(snippets)
        bad = sum(1 for x in res if not x)
        print(f"validated {len(snippets)} snippets, {bad} syntax failures")
        return

    if args.cmd == "run":
        globals()["SEEDS"] = load_seeds(refresh=args.refresh_seeds, allow_net=not args.no_net, refresh_net=args.refresh_net)
        if all(len(v) == 0 for v in SEEDS.values()):
            print("[seeds] WARNING: no seeds available -> generating TEMPLATE-ONLY. "
                  "Populate ./seeds (or allow network) to enable real phrasing.")
        else:
            print(f"[seeds] active: single={len(SEEDS['single'])} "
                  f"pipeline={len(SEEDS['pipeline'])} script={len(SEEDS['script'])} "
                  f"| seed_frac={SEED_FRAC} variant_frac={VARIANT_FRAC}")
        for b in range(args.batches):
            kept, dropped = generate_batch(state, args.batch)
            print(f"batch {b+1}/{args.batches}: +{kept} kept, {dropped} dropped "
                  f"| total {state['total']} "
                  f"(single {state['cat']['single']}, pipeline {state['cat']['pipeline']}, script {state['cat']['script']})")
            if kept == 0:
                print("no more can be generated (quota/cap/dedup exhausted) — stopping")
                break
        src = state.get("src", {})
        sg, tg = src.get("seed_groups",0), src.get("template_groups",0)
        grp = sg + tg
        print("\n---- provenance ----")
        if grp:
            print(f"requests (variant_groups): {grp}  |  "
                  f"seed {sg} = {sg/grp*100:.1f}%  |  template {tg} = {tg/grp*100:.1f}%")
        print(f"extra equivalent-answer rows: {src.get('variant_rows',0)}  |  "
              f"total rows written: {state['total']}")

if __name__ == "__main__":
    main()