#!/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 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 # 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, } # -------------------------------------------------------------------------- # 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","+10M","+50M","+100M","+500M","10k","100k","+1G","+2G","-1M"] 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) # ========================================================================== # 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) return pick( (f"Rename {a} to {a}.old", f"mv {a} {a}.old"), (f"Move {a} into the {R(SDIRS)} folder.", f"mv {a} {R(SDIRS)}/"), (f"move all .{R(EXTS)} files into the {R(SDIRS)} directory", f"mv *.{R(EXTS)} {R(SDIRS)}/"), (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(): 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 {R(SDIRS)}.", f"rmdir {R(SDIRS)}"), (f"Force-remove the {R(SDIRS)} directory and everything in it. (Careful: this is destructive and cannot be undone.)", f"rm -rf {R(SDIRS)}"), (f"Delete {R(FILES)} but ask for confirmation first.", f"rm -i {R(FILES)}"), ) @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(): return pick( (f"Create an empty file named {R(FILES)}.", f"touch {R(FILES)}"), (f"Update the modification time of {R(FILES)} to now.", f"touch {R(FILES)}"), (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) 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 {R(SDIRS)} readable and writable by the owner only.", f"chmod -R 600 {R(SDIRS)}"), (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(): return pick( (f"Change the owner of {R(FILES)} to {R(USERS)}.", f"sudo chown {R(USERS)} {R(FILES)}"), (f"Recursively set owner and group of {R(SDIRS)} to {R(USERS)}:{R(GROUPS)}.", f"sudo chown -R {R(USERS)}:{R(GROUPS)} {R(SDIRS)}"), (f"change just the group of {R(FILES)} to {R(GROUPS)}", f"sudo chgrp {R(GROUPS)} {R(FILES)}"), ) @recipe("single","find") def r_find(): d = R(DIRS) return pick( (f"Find all .{R(EXTS)} files under {d}.", f"find {d} -type f -name '*.{R(EXTS)}'"), (f"Find files in {d} larger than {R(SIZES)}.", f"find {d} -type f -size {R(SIZES)}"), (f"locate files under {d} modified in the last {R(DAYS)} days", f"find {d} -type f -mtime -{R(DAYS)}"), (f"Find empty files in {d}.", f"find {d} -type f -empty"), (f"Find directories named {R(SDIRS)} anywhere under {d}.", f"find {d} -type d -name '{R(SDIRS)}'"), (f"Find files in {d} owned by {R(USERS)}.", f"find {d} -type f -user {R(USERS)}"), ) @recipe("single","grep") def r_grep(): p,f = R(PATTERNS), R(LOGFILES) 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 {R(DIRS)} for '{p}' and show line numbers", f"grep -rn '{p}' {R(DIRS)}"), (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 {R(DIRS)} that contain '{p}'.", f"grep -rl '{p}' {R(DIRS)}"), ) @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(): return pick( (f"Convert the contents of {R(TEXTFILES)} to uppercase.", f"tr 'a-z' 'A-Z' < {R(TEXTFILES)}"), (f"Squeeze repeated spaces into a single space in {R(TEXTFILES)}.", f"tr -s ' ' < {R(TEXTFILES)}"), (f"delete all digits from {R(TEXTFILES)}", f"tr -d '0-9' < {R(TEXTFILES)}"), ) @recipe("single","ps") def r_ps(): 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 {R(USERS)}.", f"ps -u {R(USERS)}"), ("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) 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 {R(USERS)}", f"pkill -u {R(USERS)}"), ) @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(): 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 {R(PROCS)} as a tree", f"pstree -p $(pgrep -o {R(PROCS)})"), ) @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) 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 {R(USERS)}", f"renice -n 15 -u {R(USERS)}"), ) @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) 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 {R(DAYS)} days", f"journalctl -u {s} --since '{R(DAYS)} 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) return pick( (f"Determine the file type of {f}.", f"file {f}"), (f"check the type of every file in {R(SDIRS)}", f"file {R(SDIRS)}/*"), ) @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(): return pick( ("Show the current git status in short form.", "git status -s"), (f"Create and switch to a new branch called {R(BRANCHES)}.", f"git checkout -b {R(BRANCHES)}"), ("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 {R(BRANCHES)} branch.", f"git pull origin {R(BRANCHES)}"), ("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) return pick( (f"SSH into {h} as {u}.", f"ssh {u}@{h}"), (f"connect to {h} on port {R(PORTS)} as {u}", f"ssh -p {R(PORTS)} {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) return pick( (f"Copy {f} to {h}'s /tmp directory as {u}.", f"scp {f} {u}@{h}:/tmp/"), (f"download /var/log/{R(LOGFILES)} from {h} to the current dir", f"scp {u}@{h}:/var/log/{R(LOGFILES)} ."), ) @recipe("single","rsync") def r_rsync(): a,b = R(SDIRS), R(SDIRS) h = R(HOSTS) 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}/ {R(USERS)}@{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(): return pick( (f"Show the user and group IDs for {R(USERS)}.", f"id {R(USERS)}"), ("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(): 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 {R(PROCS)} processes", f"top -p $(pgrep -d, {R(PROCS)})"), ) @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(): 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 {R(PORTS)}?", f"ss -tn | grep ':{R(PORTS)}' | 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) 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 .{R(EXTS)} files in {d}", f"ls {d} | grep '\\.{R(EXTS)}$'"), ) 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(): 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 {R(PORTS)}", f"lsof -ti :{R(PORTS)} | 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) return pick( (f"Archive {d} and pipe it over ssh to back it up on a remote host.", f"tar -czf - {d} | ssh {R(USERS)}@{R(HOSTS)} '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) 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 {R(FILES)} exists and cat it, otherwise say it's missing.", f"[ -f {R(FILES)} ] && cat {R(FILES)} || 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" <&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.", ) 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" # -------------------------------------------------------------------------- # engine # -------------------------------------------------------------------------- def load_state(): counts_cat = {"single":0,"pipeline":0,"script":0} counts_util = {} seen = set() total = 0 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 counts_cat[o["category"]] = counts_cat.get(o["category"],0)+1 counts_util[o["utility"]] = counts_util.get(o["utility"],0)+1 h = hashlib.sha1((nl+"\x00"+bash).encode()).hexdigest() seen.add(h) return {"total":total,"cat":counts_cat,"util":counts_util,"seen":seen} 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): snap = { "total": state["total"], "target_total": TARGET_TOTAL, "category_target": CAT_TARGET, "category_counts": state["cat"], "util_cap": UTIL_CAP, "util_counts": dict(sorted(state["util"].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 generate_batch(state, batch_size): cand = [] provisional_util = {} provisional_cat = {} 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} # Floor pass: 60% of the time, preferentially fill under-floor utilities. # Probabilistic so an unreachable floor can never stall the batch. rec = cat = None if random.random() < 0.6: dr = choose_deficit_recipe(merged, cat_now) if dr is not None: rec, cat = dr if rec is None: cat = choose_category({"cat":cat_now}) if cat is None: break rec = choose_recipe(cat, {"util":merged}) if rec is None: continue res = rec["fn"]() if len(res) == 3: nl, bash, util = res # recipe supplied a dynamic utility else: nl, bash = res util = rec["utility"] # enforce the real per-utility cap (works even for dynamic labels) if merged.get(util, 0) >= UTIL_CAP: continue h = hashlib.sha1((nl+"\x00"+bash).encode()).hexdigest() if h in state["seen"]: continue state["seen"].add(h) cand.append({"nl":nl,"bash":bash,"category":rec["category"], "utility":util,"_h":h}) provisional_util[util] = provisional_util.get(util,0)+1 provisional_cat[cat] = provisional_cat.get(cat,0)+1 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 kept # alongside for quota tracking / resume (trainers just read "messages"). 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"]} fh.write(json.dumps(row, ensure_ascii=False)+"\n") state["total"] += 1 state["cat"][c["category"]] = state["cat"].get(c["category"],0)+1 state["util"][c["utility"]] = state["util"].get(c["utility"],0)+1 save_progress(state) return len(kept), dropped def cmd_status(state): print(f"total written: {state['total']} / {TARGET_TOTAL}") for c in CAT_TARGET: print(f" {c:9s}: {state['cat'].get(c,0):6d} / {CAT_TARGET[c]}") print(f"distinct utilities: {len(state['util'])}, cap per utility: {UTIL_CAP}") over = [(u,n) for u,n in state['util'].items() if n>UTIL_CAP] if over: print(" OVER CAP:", over) top = sorted(state['util'].items(), key=lambda x:-x[1])[:12] print(" top utilities:", ", ".join(f"{u}={n}" for u,n in top)) 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"]) ap.add_argument("--batch", type=int, default=500) ap.add_argument("--batches", type=int, default=1) ap.add_argument("--target", type=int, default=None) args = ap.parse_args() state = load_state() if args.target: globals()["TARGET_TOTAL"] # keep simple; target override not persisted 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": 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 if __name__ == "__main__": main()