dot_bash_aliases

# shellcheck shell=bash
# vim:ft=bash
# if possible, this file should remain under 1000 LOC.

# autostart {{{

[[ -f /tmp/verse.json ]] && [[ -s /tmp/verse.json ]] &&
	< /tmp/verse.json jq -r '.votd | .reference, .content' |
	sed -e 's/<[^>]*>//g' |
		fold -w 65 -s
# echo

# }}}
# aliases {{{

# alias ws=wallset
alias dr=discogs_rate
alias ex=extract
alias gm=getmail
alias lc=leetcode.py # shadows lc binary (who?)
alias mb=musicbrainz
alias met=metronome
alias ns=notify-send
alias trk=trackratings.py
alias tt=taptempo
alias xo=xdg-open

alias rab="exec yazi \"\$HDD/books\""
alias rad="exec yazi \"\$SLSK/complete\"" # TODO: investigate `ya pub`
alias rag="exec yazi \"\$HDD/guitar\""
alias rat="exec yazi \"\$HDD/torrent\" \"\$HDD/movies\""

# alias n="NO_COLOR=1 node --import=tsx"
alias ..="cd .."
alias au="audacious -H"
alias bh="vb -b"
alias cam="ls /dev/video* && mpv --fs av://v4l2:/dev/video0 --profile=low-latency --untimed && exit" # TODO: handle >1 video device (just increment n until file not exist)
alias ci="chromium --incognito"
alias con="convert_files && fix_genres --auto && fix_tags -a && fix_tags && fix_genres && ~/gripts/mover/mover" # && notify-send ok"
alias csv="python -c 'import sys; import pandas; print(pandas.read_csv(sys.argv[1]))'"
alias ctz="sudo timedatectl set-timezone \$(timedatectl list-timezones | grep / | fzf)" # TODO: geolocate
alias da="dc artist:"
alias dc="discogs_collection filter"
alias dt="discogs_collection top"
alias feh="feh --draw-filename --fullscreen --auto-zoom --sort name --version-sort"
alias h="htop -u \$USER"
alias li="chromium --incognito 'https://www.linkedin.com/notifications/?midToken=AQECUGJ6GKhRSg' & exit"
alias lock="[[ -d /sys/class/power_supply/BAT0 ]] && systemctl suspend && slock"
alias md="\$EDITOR -c 'set ft=markdown'"
alias mem="top -b -n1 -o %MEM | grep -m10 \$USER"
alias or="cd ~/gripts/oar && time ./oar && waitdie mpv && mpv --profile=bcx ./out && rm -rI ./out"
alias pq="~/plaque/plaque"
alias rgl="rg --no-heading --with-filename"
alias synctime="sudo ntpd --quit --panicgate"
alias t="wezterm start --new-tab --cwd \$(realpath .)"
alias tf="waitdie con; fix_tags"
alias tmp="cd \$(mktemp -d)"
alias trizen="trizen --aur-results-sort-by=votes --aur-results-sort-order=ascending"
alias tx="tectonic -X"
alias tz=trizen # if gpg fail, gpg --recv-keys <key>
alias vf="\$EDITOR \$(fzf)"
alias y="bash ~/gripts/disq/ytm.sh"

# }}}

# git {{{

# shellcheck disable=SC2120
gls() { git ls-files "${1:-.}"; }
get_repo_root() { git rev-parse --show-toplevel 2> /dev/null; }
alias groot=get_repo_root

cdr() {
	if git rev-parse --is-inside-work-tree > /dev/null 2>&1; then
		cd "$(get_repo_root)" || :
	elif [[ -n $REPO ]]; then
		cd "$REPO" || :
	fi

}

alias cr=cdr

gmaster() {
	: get default branch, e.g. master
	# https://stackoverflow.com/a/44750379
	# default_branch=$(git symbolic-ref refs/remotes/origin/HEAD | sed 's|^refs/remotes/origin/||')
	git symbolic-ref refs/remotes/origin/HEAD 2> /dev/null | cut -d/ -f4
}

gunb() {
	gun .
	gB
}

gb() {
	: switch to new branch, or existing branch

	# no remote branches
	default_local_branch=$(gmaster) || :
	current_local_branch=$(git branch --show-current)

	if [[ $# -eq 0 ]]; then
		if [[ $default_local_branch == "$current_local_branch" ]]; then
			echo "Already on $default_local_branch"
		else
			# func retval is not propagated to parent
			git checkout "$default_local_branch" || return 1
			timeout 30 git pull
		fi
	else

		# generally, new branches should target master. however, this
		# may not always be the case, so accept an optional 2nd arg to
		# specify target branch (should be current)
		if ! git checkout "${2:-$default_local_branch}"; then
			return 1
		fi

		timeout 30 git pull || return

		# existing remote branch > create local branch > existing local branch
		if
			git branch -r | grep "origin/$1"
		then
			# note: git hook stdout cannot be suppressed
			echo "Switching to remote branch $1"
			git switch "$1" || return 1

		elif git switch --create "$1"; then
			# git switch --create does not produce output, for some
			# reason (but git switch does)
			echo "Switched to new branch $1"

		else
			# should be infallible?
			git switch "$1" || return 1

		fi
	fi

}

gB() {
	# https://stackoverflow.com/a/1441062
	# --pretty=format:'%h%x09%an%x09%ad%x09%s' # no color
	# TODO: include date/author, but preserve color
	# TODO: handle master..master
	prv_cmd="echo {} | sed -r 's/^[ *]+//; s/^/master../' | xargs git log --oneline --color=always"
	branch=$(git branch --sort=-committerdate |
		fzf --preview="$prv_cmd" --preview-window='right,80%,border' --ansi |
		sed -r 's/^[ *]+//')
	[[ -z $branch ]] && return
	gb "$branch"
}

gbd() {
	: prune local branches that no longer exist on remote -- unstaged changes will be lost!
	# https://stackoverflow.com/a/46192689
	git branch -vv |
		grep ': gone]' |
		grep -v "\*" |
		awk '{ print $1; }' |
		xargs -r git branch -D
}

gba() {
	: show all branches with author
	# https://stackoverflow.com/a/19135644
	git for-each-ref --format='%(committerdate:iso)%09%(authorname)%09%(refname)' |
		grep remotes |
		sort |
		column -t -s '	'
}

gbcp() {
	: cherry pick commit from other branch

	prv_cmd="echo {} | cut -d' ' -f1 | xargs git show --color=always"
	sha=$(git log --branches --remotes --tags --oneline --decorate |
		fzf --preview="$prv_cmd" --preview-window='right,60%,border' --ansi |
		awk '{print $1}')

	# https://stackoverflow.com/a/29788254
	[[ -n $sha ]] && git show "$sha" | git apply -
}

_() {

	# https://nitaym.github.io/ourstheirs/

	# # merge: attempt to apply (bring in) changes from feature, then master
	# git checkout master
	# git merge $feature_branch
	# git checkout --ours $conflict_file   # to select the changes done in master
	# git checkout --theirs $conflict_file # to select the changes done in $feature_branch
	# git add $conflict_file
	# git merge --continue

	# # rebase: attempt to apply changes from master, then from feature
	# git checkout $feature_branch
	# git rebase master
	# git checkout --ours $conflict_file   # to select the changes done in master
	# git checkout --theirs $conflict_file # to select the changes done in $feature_branch
	# git add $conflict_file
	# git rebase --continue

	:
}

_gld() {
	prv_cmd="echo {} | cut -d' ' -f1 | xargs git show --color=always"
	{
		if [[ -f $1 ]] || [[ -d $1 ]]; then
			git log --oneline "$@"
		else
			git log --oneline
		fi
	} |
		fzf --preview="$prv_cmd" --preview-window='right,60%,border' --ansi
}

gld() {
	: browse git log, showing each commit\'s diff in fzf preview
	_gld "$@" | awk '{print $1}' | xargs git show
}

gsdel() {
	: show last state of a deleted file
	# https://stackoverflow.com/a/19727752
	f=$1
	git show "$(git rev-list --max-count=1 --all -- "$f")^:$f"
}

gS() {
	: like gs+gld, for files to stage/commit

	# # porcelain v1 is -always- relative to repo root, which makes parsing harder
	# files=$(git status --porcelain)

	# https://git-scm.com/docs/git-status#_changed_tracked_entries
	# $2 is more useful for tracked files (since it more closely maps to v1
	# labels), but for untracked files this duplicates the file path, so we
	# stick to $1
	# HACK: i have no idea how to 'return' multiple columns inside a
	# ternary, so concat with a space as an ugly workaround
	files=$(git status --porcelain=2 | awk '{print ($1=="?") ? $1" "$NF : $2" "$NF}')
	# note: untracked files have no diff
	prv_cmd="echo {} | awk '{print \$NF}' | xargs git diff --color=always"
	sel=$(<<< "$files" fzf --multi --reverse --preview="$prv_cmd" --preview-window='right,60%,border' --ansi)
	echo "$sel" |
		grep -P '^\?' | # add untracked files first
		awk '{print $NF}' |
		xargs git add
	echo "$sel" | awk '{print $NF}' | xargs git commit -v
}

gac() {
	: append ALL changes to most recent unpushed commit
	git add "$@"
	git commit --amend --no-edit
}

gapc() {
	git add --patch "$@"
	git commit --amend --no-edit
}

# delete and ignore file, without untracking. warning: the only way to recover
# is to re-download from repo!
# https://stackoverflow.com/a/45149731
# git update-index --assume-unchanged <file>

gL() {
	: show commits \(hash+msg\) made in the last week
	# TODO: allow file/dir $1
	d=$(date --date="1 week ago")
	git logline --since="$d" --no-merges | tac
}

gcf() {
	: make a new commit to be squashed with an earlier one

	# https://jordanelver.co.uk/blog/2020/06/04/fixing-commits-with-git-commit-fixup-and-git-rebase-autosquash/
	sha=$(_gld . | cut -d' ' -f1)
	[[ -z $sha ]] && return

	# --fixup associates a new commit with an existing commit so that when
	# you do an interactive rebase, you don't have to re-order any commits
	# in order to squash them. And you don't have to change any commit
	# messages
	git commit --fixup "$sha" "$@"

	# TODO: not sure what to do yet when unstaged changes are present

	# with no arg, defaults to curr branch (NEVER use gmaster; to avoid
	# losing work, git rebase --abort immediately)
	# is -i necessary?
	git rebase -i --autosquash || gC
}

gA() {
	: un-add, unstage
	git restore --staged "$@" \
		2> /dev/null || # committed; without --staged, changes are discarded!
		git reset "$@"  # not committed yet
}

gc() {

	if [[ $# -gt 0 ]]; then

		# 1. specified files, but excluding untracked files
		# note: this loop commits renamed files, but does not commit
		# their old names
		arr=()
		for f in "$@"; do
			[[ ! -f $f ]] && continue
			git ls-files | grep -q "$(basename "$f")" && arr+=("$f")
		done

		git commit -v "${arr[@]}"

	elif
		# 2a. file(s) that have been renamed/deleted
		git status --porcelain | grep -Pq '^R.+ -> '
	then
		pushd "$(get_repo_root)" || return
		git status --porcelain |
			grep -P '^R' |
			sed 's/^R[^ ]* //; s/->//' | # very iffy
			# ideally, i want this (to avoid pushd), but xargs cannot be used on func
			# xargs prepend "$(get_repo_root)"/ |
			# realpath --relative-to=.
			xargs git commit -v
		popd || return

	elif
		# 2b. file(s) that have been renamed/deleted
		git status --porcelain | grep -Pq '^(R | D)'
	then
		git status --porcelain |
			grep -P '^(R | D)' |
			awk '{print $2}' | # iffy
			xargs git commit -v

	elif
		# 3. all staged changes
		staged=$(git diff --name-only --cached --diff-filter=AMD) &&
			[[ -n $staged ]]
	then
		git commit -v

	else
		# 4. all files that have changed in the current dir
		git diff --name-only |
			prepend "$(get_repo_root)/" |
			grep "$PWD" |
			xargs git commit -v

	fi

}

gs() {
	# 1. changed files (twice: porcelain, then diff stat)
	# 2. untracked files
	# 3. current number of staged commits

	# (1)
	#  M discogs.go
	#  M discogs_test.go
	#  M main.go
	#
	#  discogs.go      |  2 +-
	#  main.go         |  2 +-
	#  discogs_test.go |  6 +++---
	#
	# (2)
	# util_test.go
	#
	# (3)
	# No commits staged.

	if
		! git rev-parse --is-inside-work-tree > /dev/null 2>&1
	then
		return
	elif
		# new repo
		git status | grep -q 'No commits yet'
	then
		git status
		return
	fi

	# shellcheck disable=SC2164
	[[ $# -eq 1 ]] && [[ -d $1 ]] && pushd "$1" > /dev/null

	# 1

	# note: colors are lost when piping, but sort is more useful than color
	if
		diffs=$(
			git diff --stat ./ | # generally, i only want to see the diff stat for current dir
				grep -F '|' |       # ignore summary line
				sort -n -k3         # most changes last (more useful in short terminals)
		)
		[[ -n $diffs ]]
	then
		{ git status --porcelain | grep -Fv '??'; } 2> /dev/null
		echo
		echo "$diffs"
	elif
		# newly staged files are -not- included in git diff
		files=$(git status --porcelain |
			grep '^A' |
			awk '{print $NF}' |
			# make paths absolute (default: relative to root)
			prepend "$(get_repo_root)/" |
			# then relativise to cwd
			largs realpath --relative-to=. 2> /dev/null) &&
			[[ -z $files ]]
	then
		: no files added
	else
		echo "$files" | column -t | while read -r f; do
			lines=$(< "$f" wc -l)
			echo "./$f | $lines +"
		done <<< "$files" | column -t
	fi
	echo

	# 2

	if
		untracked=$(git ls-files --others --exclude-standard) &&
			num_untracked=$(<<< "$untracked" wc -l) &&
			[[ $num_untracked -ge $LINES ]]
	then
		echo "[$num_untracked untracked files]"
		echo
	elif [[ -n $untracked ]]; then
		echo "$untracked"
		echo
	fi

	# 3

	git status | grep -P '\d+ commits?' || echo 'No commits staged.'

	popd > /dev/null 2> /dev/null || :
}

gp() {
	: push current branch

	# shellcheck disable=SC2164
	[[ $# -eq 1 ]] && [[ -d $1 ]] && pushd "$1"

	if ! git config --get remote.origin.url > /dev/null; then
		echo 'no remote; try gnew'
		return
	fi

	if ! git log > /dev/null; then
		echo 'no commits yet; try gc'
		return
	fi

	gpl

	# --set-upstream[-to]: sets the default remote branch for the current
	# local branch

	git push --set-upstream origin "$(git rev-parse --abbrev-ref HEAD)"

	# shellcheck disable=SC2164
	[[ $# -eq 1 ]] && popd

}

gpl() {
	: pull

	# [[ $# -eq 1 ]] && cd "$1"

	# TODO: pull/update?
	# git pull --recurse-submodules	# didn't seem to work (reverts to commit of parent)
	# git submodule sync
	# git submodule update --init --recursive
	# git submodule update --remote --merge
	# https://devconnected.com/how-to-add-and-update-git-submodules/#Pull_a_Git_Submodule
	# https://stackoverflow.com/questions/10054011

	if git branch -r | grep -q 'upstream/'; then
		# pull from upstream
		# git remote add upstream "$UP"
		echo "Pulling from upstream"
		git fetch upstream
		git rebase upstream/main # or whatever
		# merge as usual...
	else

		# git pull

		git fetch

		# set -x
		if
			# this is the closest builtin that comes close
			# git diff --name-status master origin/master
			pullresult=$(git merge 2>&1) # fail = exit 2
			[[ $? -eq 2 ]] &&
				conflicts=$(sed <<< "$pullresult" -rn 's|^\s+||p') &&
				[[ -n $conflicts ]]
		then
			while read -r -u9 conflict; do
				notify-send "Conflict" "$conflict"
				git commit -v "$conflict"
			done 9<<< "$conflicts"
			git pull
		else
			echo "$pullresult"
		fi
		# set +x

	fi

	# git submodule foreach git pull origin master
	# assumes all submodules at repo root
	for sub in $(git submodule | cut -d' ' -f2-); do
		cd "$sub" || continue
		echo -e "\nUpdating submodule: $sub"
		gpl
		cd ..
	done

}

gmm() {
	: merge master into dev branch
	# https://stackoverflow.com/a/20103414
	git fetch origin # gets you up to date with origin
	git merge origin/master
}

gh() {
	: open remote url

	if ! repo=$(git config --get remote.origin.url); then
		echo "Current repo has no remote"
		return
	fi
	repo=${repo%*.git}

	if [[ -f $1 ]] && git ls-files --error-unmatch "$1" &> /dev/null; then
		# TODO: path must be relativised to repo root (rev-parse?)
		# i.e. realpath - repo_root

		# view file at its most recent commit
		hash=$(git log -n 1 --pretty=format:%h -- "$1")
		URL="$repo/blob/$hash/$1"

	elif [[ -n $1 ]]; then # view repo at specific commit
		# TODO: git log oneline -> fzf
		h=$(git rev-parse --short --verify HEAD)
		URL="$repo/commit/$h"

		# URL="$repo/tree/$1"

	else
		URL="$repo"
	fi

	# URL=$(sed -r 's/[^/]+@//' <<< "$URL")

	[[ $URL != http* ]] && URL=$(tr <<< "$URL" : / | sed -r 's|git@|https://|')

	echo "$URL"
	# ubuntu is a pita:
	# gio: ...: Failed to find default application for content type ‘text/html’
	xdg-open "$URL" ||
		firefox "$URL"
}

gnew() {
	: push to newly created remote

	if [[ -f files_to_add ]]; then
		if [[ -d .git ]] && [[ -d .git_old ]]; then
			echo 'new and old git histories found, remove new one first: rm -rf ./.git'
			return
		fi
		mv .git .git_old
	fi

	# echo $GIT_EMAIL
	# return

	# https://kbroman.org/github_tutorial/pages/init.html
	# set -euo pipefail

	# no repo yet
	if [[ ! -d .git ]]; then
		git init
		return
	fi

	if
		! git log > /dev/null 2> /dev/null &&
			! git status --porcelain | grep -Fv '??'
	then
		echo 'no commits made yet'
		return
	else
		# WARN: this may not be desired
		git commit -m "initial commit"
	fi

	# no remote yet
	if ! git config --get remote.origin.url; then
		git branch -M master
		xdg-open https://github.com/new &
		read -rp 'Repo name (not URL!): ' repo
		git remote add origin "https://github.com/hejops/$repo"
		git push -u origin master
		git status
	fi

}

gssh() {
	: init github ssh key
	# https://docs.github.com/en/authentication/connecting-to-github-with-ssh/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent#generating-a-new-ssh-key
	#
	# note: this key must still be added to github!
	# https://docs.github.com/en/authentication/connecting-to-github-with-ssh/adding-a-new-ssh-key-to-your-github-account#adding-a-new-ssh-key-to-your-account

	# password not strictly necessary
	ssh-keygen -t ed25519 -C hejops1@gmail.com -f "$HOME/.ssh/github_$(date -I)"
	ssh -T git@github.com 2>&1 | grep -q success && echo ok

	# to actually use the key on startup, add to .xinitrc (or similar);

	# if [[ -z $SSH_AUTH_SOCK ]]; then
	# 	{
	# 		pkill ssh-agent
	# 		eval "$(ssh-agent -s)"
	# 		ssh-add "$HOME/.ssh/github_2024-06-17"
	# 	} > /dev/null 2> /dev/null
	# fi

}

gd() {
	if [[ $# -eq 0 ]]; then
		git diff
	elif
		# no local changes, check against last commit
		[[ $# -eq 1 ]] &&
			git diff --exit-code "$1" > /dev/null
	then
		git diff HEAD^^ "$1"
	else
		git diff "$@"
	fi
}

gdm() {
	: diff against master, like in a PR

	# caveat: due to git internals, it is not trivial to produce a diff
	# that is both 'cumulative' and completely excludes merges.
	#
	# https://stackoverflow.com/q/25403705
	#
	# this gets reasonably close, but if a file was changed in the current
	# branch as well as in a merge, both changes will be shown. for the
	# purpose of fast diffing (i.e. without network), this is usually fine.

	span="$(gmaster)...HEAD"
	git log --no-merges --first-parent --name-only --oneline --pretty= "$span" |
		sort -u |
		xargs git diff "$span"

	# if command -v glab > /dev/null; then
	# 	glab mr diff |
	# 		grep -v Subproject | # https://github.com/dandavison/delta/issues/1943
	# 		delta
	# else
	# 	# includes merges (can be noisy)
	# 	git diff "$(gmaster)...HEAD"
	# fi

}

gcon() {
	: resolved conflicts, if any, and merge

	# git diff --name-only --diff-filter=U --relative

	if ! git status --porcelain | grep UU; then
		echo "No conflicts detected"
	fi

	# all conflicts are due to lock files
	if ! git status --porcelain | grep UU | grep -v yarn.lock; then
		git status --porcelain |
			grep UU |
			cut -d' ' -f2- |
			xargs dirname |
			while read -r d; do
				pushd "$d" || return
				yarn install || return
				git add yarn.lock
				popd || return
			done
		rg '^[<=>]{7}' && return
		git commit -v
		return
	fi

	while rg '^[<=>]{7}'; do
		echo "Unresolved conflicts remaining!"
		# TODO: may not only be UU
		git status --porcelain | grep UU | cut -d' ' -f2- | xargs nvim -p
	done

	git status --porcelain | grep UU | cut -d' ' -f2 | xargs git add
	git commit -v
}

gapat() {
	: stage hunks matching some pattern

	# # https://choly.ca/post/git-programmatic-staging/
	# git diff |
	# 	# TODO: grepdiff seems to match entire context surrounding the
	# 	# matches, instead of just the surrounding lines
	# 	# might be useful: --only-match=rem|removals|add|additions|mod|modifications|all
	# 	grepdiff --output-matching=hunk "$1" |
	# 	git apply --cached

	# # https://old.reddit.com/r/git/comments/p1vltk
	# git diff -U0 |
	# 	grepdiff --output-matching=hunk "$1" |
	# 	# "By default, git apply expects that the patch being applied
	# 	# is a unified diff with at least one line of context."
	# 	git apply --cached --unidiff-zero

	# https://stackoverflow.com/a/52394658
	git diff --unified=1 --pickaxe-regex -S "$1" |
		grepdiff --output-matching=hunk --extended-regexp "$1" |
		git apply --cached

	# see also:
	# http://www.philandstuff.com/2014/02/09/git-pickaxe.html
	# https://git-scm.com/docs/gitdiffcore#_diffcore_pickaxe_for_detecting_additiondeletion_of_specified_string

	git commit -v

	# # unstage hunks that were unnecessarily added
	# git reset -p
}

ggiturl() {
	: replace http url with git
	<<< "$1" sed 's|http://|git@|; s|/|:|; s/$/.git/'
}

gclone() {
	ggiturl "$1" | xargs git clone
}

gUN() {
	: undo and discard last committed commit, useful on master
	# https://stackoverflow.com/a/6866485
	git reset --hard HEAD~1
}

# $(git config --get remote.origin.url)/-/merge_requests/new?merge_request%5Bsource_branch%5D=$branch

guns() {
	: revert file to its state in a previous commit
	f=$1
	sha=$(_gld "$1" | awk '{print $1}')
	git checkout "$sha" -- "$f"
}

# }}}

# python {{{

# i haven't worked in python in a while, so this may be cleaned up

pydeps() {
	# https://stackoverflow.com/a/75344709
	mapfile -t args < /dev/stdin
	python -c 'import sys
for i in sys.argv[1:]:
    if i.split(".")[0] not in sys.stdlib_module_names:
        print(i)' "${args[@]}"
}

genuv() {
	: generate dependencies of a uv script
	# assumes there are no 1st party imports; when generating dependencies
	# of a uv script, this is probably true
	deps=$(< "$1" grep -P '^(from|import)' | cut -d' ' -f2 | sort -u | pydeps)
	[[ -z $deps ]] && return

	cat << EOF
# /// script
# dependencies = [
$(echo "$deps" | while read -r dep; do echo "#   \"$dep\","; done)
# ]
# ///
EOF

}

alias pt='gls | grep 'test_.\*py' | xargs pytest -x -vv --disable-warnings'

pget() {
	pyp=$(groot)/pyproject.toml

	if [[ -f $pyp ]]; then
		echo "not in python project"

	elif < "$pyp" grep -Fq tool.poetry; then
		poetry add "$1"

	elif command -v uv > /dev/null; then
		uv add "$1"
	fi
}

pup() {
	pyp=$(groot)/pyproject.toml

	if [[ -f $pyp ]]; then
		echo "not in python project"

	elif < "$pyp" grep -Fq tool.poetry; then
		poetry update "$1"

	elif command -v uv > /dev/null; then
		uv lock --upgrade-package "$1"
	fi
}

pentmd() {
	: render entry points as markdown
	# - [`poetry run XXX`](./path/to/script.py)
	# shellcheck disable=SC2016
	grep < pyproject.toml :main |
		sed -r 's|^([^ ]+) = "([^:]+):main"|- [`poetry run \1`](./\2.py)|g' |
		tr . / |
		sed -r 's#/(/|py)#.\1#g'
}

# }}}
# django {{{

alias djnew='django-admin startproject'
alias djs='./manage.py runserver'

djrmdb() {
	# nuke db and rebuild
	# https://simpleisbetterthancomplex.com/tutorial/2016/07/26/how-to-reset-migrations.html
	# https://stackoverflow.com/questions/29253399/how-to-reset-migrations-in-django-1-7#comment67199335_29266821
	find . -path "*/migrations/*.py" -not -name "__init__.py" -delete
	find . -path "*/migrations/*.pyc" -delete
	rm ./db.sqlite3
	./manage.py makemigrations "$1"
	./manage.py migrate
}

djapp() {

	[[ -d $1 ]] && return
	app=$1

	./manage.py startapp "$app"

	# startapp doesn't create urls.py
	cat << EOF > "$app"/urls.py
from django.urls import path

from . import views

app_name = "$app"

urlpatterns = [
    # https://docs.djangoproject.com/en/5.0/ref/urls/#django.urls.path
    path(
        route="",
        view=views.IndexView.as_view(),
        name="index",
    ),
]
EOF

	mkdir -p "$app/templates/$app"
	touch "$app/templates/$app/index.html"

	cat << EOF >> "$app"/views.py
from django.views import generic
from django.shortcuts import get_object_or_404
from django.db.models import F

from $app.models import *


class IndexView(generic.ListView):
    template_name = "$app/index.html"  # default: <app name>/foo_list.html

    context_object_name = "foo"

    def get_queryset(self):
        return Foo.objects.filter().order_by("pk")
EOF

	# {% load static %}
	# <link rel="stylesheet" href="{% static '${app}s/style.css' %}" />
	# {% if ${app}_list %}
	#     <ul>
	#         {% for ${app} in ${app}_list %}
	#             <li>
	#                 <!-- explicit namespacing `app_name` to be declared in ${app}s/urls.py -->
	#                 <a href="{% url '${app}s:detail' ${app}.name %}">{{ ${app}.name }}</a>
	#             </li>
	#         {% endfor %}
	#     </ul>
	# {% else %}
	#     <p>No ${app}s are available.</p>
	# {% endif %}

}

# }}}
# rust {{{

# cargo +nightly udeps
alias cb="cargo build"
alias cbr="cargo build --release && cp target/release/\$(basename \$PWD) ."
alias ct="cargo test"
alias cwr="cargo watch -x run"                           # web servers only
alias sqp='cargo sqlx prepare --workspace; ga .sqlx; gc' # postgres only

sqre() {
	# regen sqlite db
	# often required for sqlite, possibly when .sql files are modified are migration
	# https://github.com/launchbadge/sqlx/discussions/1292#discussioncomment-3015486
	sqlx database drop
	sqlx database create
	sqlx migrate run
}

cw() {
	cargo watch -x check -x "test $1"
}

rsmod() {

	if [[ -f $1 ]]; then

		# convert foo/bar.rs -> foo/bar/mod.rs
		rs=$1
		base=${rs/.rs/}
		mkdir -p "$base"
		mv "$rs" "$base/mod.rs"
		# TODO: update lib, pub use, etc

	elif [[ -n $1 ]]; then

		echo "Creating module $1"

		echo "pub mod $1;" >> src/lib.rs # doesn't work?
		mkdir -p "src/$1"
		mod="src/$1/mod.rs"
		# touch "$mod"
		echo "mod foo;" >> "$mod"
		echo "pub use foo::*;" >> "$mod"

	fi

}

# }}}
# go {{{

# https://gist.githubusercontent.com/alexedwards/3b40775846535d0014ab1ff477e4a568/raw/15f15b499f626a6e3949c237d52a3e8aace1b05b/Makefile

# alias gonew=gon
alias gobe="go test -bench=. -run=^$ ./..."         # run benchmarks only -- https://stackoverflow.com/a/16161605
alias gor="\ls *.go | grep -v _test | xargs go run" # won't work with args

gop() {
	# https://go.dev/blog/pprof

	# https://github.com/google/pprof/blob/a8630aee4ab9e36dfc54c2e0a4df49abb8345dbd/internal/driver/commands.go#L125
	go tool pprof -web -nodefraction=0.1 ./*.prof 2> /dev/null
}

gopk() {
	: move foo.go to foo/foo.go
	# parent must then import from foo; goimports should fix this?
	f=$1
	pkg=${f/.go/}
	[[ -d $pkg ]] && return
	mkdir "$pkg"
	sed -i -r "s/^package main/package $pkg/" "$f"
	mv "$f" "$pkg"
}

gon() {
	[[ $# -ne 1 ]] && return
	[[ -d $1 ]] && return
	if [[ -f ./go.mod ]]; then
		mkdir "$1"
		echo -e "package $1\nfunc foo(){\n}" > "$1/$1.go"
		vim + "$1/$1.go"
	else
		mcd "$1"
		go mod init "$1"
		echo "$1" > .gitignore
		echo -e "func main(){\n}" > main.go
		go build # generate go.mod
		vim + main.go
	fi
}

gob() { # build and run (gor won't work with args)
	name=$(< go.mod head -n1 | cut -d' ' -f2)
	go build && ./"$name" "$@"
}

gorep() {
	patt=$1
	repl=$2

	# # see matches
	# rg -IN "$patt" ./*.go
	# read -r -p 'press enter to preview changes'

	# preview changes
	# note: gofmt can only modify expressions, not func declarations!
	gofmt -r "$patt -> $repl" ./*.go | less
	read -r -p 'press enter to accept changes'

	# execute
	gofmt -r "$patt -> $repl" -w ./*.go
}

# https://leg100.github.io/en/posts/building-bubbletea-programs/

# ideally i would like gow to be spawned in a background tab (not window!),
# then gowr in the main tab, BUT wezterm tabs mess with bubbletea dims
gow() {
	: watch code changes, trigger re-build, and kill process

	cdr
	find . -name '*.go' | entr -cr go test ./...

	# [[ ! -f go.mod ]] && return
	# name=$(< go.mod head -n1 | cut -d' ' -f2)
	# while :; do
	# 	go build && pkill "$name"
	# 	# inotifywait --event attrib $(find . -name '*.go') > /dev/null || return
	# 	find . -name '*.go' -print0 | xargs -0 inotifywait --event attrib > /dev/null || return
	# done

}
gowr() { while :; do gob "$@" || break; done; } # in foreground, continously run app

# }}}
# js {{{

npmup() {
	: upgrade npm package
	pkg=$1
	# TODO: list package.json
	c "https://www.npmjs.com/package/$1?activeTab=versions" |
		grep -Po '\d+?\.\d+?\.\d+?</a></td><td class="downloads">[0-9,]+' |
		sed -r 's|</a></td><td class="downloads">|\t|' |
		sort -k2n
	# yarn upgrade "$pkg@^$ver"
}

perfnode() {
	if [[ $# -gt 0 ]]; then
		# creates perf.data
		perf record -e cycles:u -g -- node --perf-basic-prof "$@"
	elif [[ -f perf.data ]]; then
		# https://nodejs.org/en/learn/diagnostics/flame-graphs#create-a-flame-graph-with-system-perf-tools
		# https://speakerdeck.com/mrfoto/what-are-flame-graphs-and-how-to-read-them
		perf script | # reads perf.data
			# remove internal
			sed -r -e "/( __libc_start| LazyCompile | v8::internal::| Builtin:| Stub:| LoadIC:|\[unknown\]| LoadPolymorphicIC:)/d" \
				-e 's/ LazyCompile:[*~]?/ /' |
			# show only user defined functions
			grep -e "$USER" -e '^\S' -e '^$' |
			stackvis perf > flamegraph.htm
		chromium flamegraph.htm 2> /dev/null &
	fi
}

nps() {
	# vite is probaly the way to go...

	# # xdg default browser always overrides BROWSER var
	# # https://github.com/facebook/create-react-app/issues/9531#issuecomment-1022412062
	# BROWSER=chromium npm start

	# https://peter.sh/experiments/chromium-command-line-switches/#auto-open-devtools-for-tabs
	chromium --auto-open-devtools-for-tabs http://localhost:3000 &
	BROWSER=none npm start
}

# }}}
# c {{{

x() {
	n=$(basename "$(realpath .)")
	gcc -o "$n" ./*.c && "./$n"
}

mch() {
	# f=$1

	: [re]generate header files
	for f in *.c; do
		[[ $f == main.c ]] && continue

		h="${f/.c/.h}"
		if [[ -f $h ]]; then
			# for merge to work, fn decls must all be placed at the
			# bottom of the .h file. includes, macros, structs
			# should be placed at the top. (is there a recommended
			# order?)
			{
				< "$h" grep -Pv '\);$' # discard existing fn decls
				cproto "$f" | sed 1d   # cproto only generates fn decls
			} | sponge "$h"
		else
			cproto "$f" > "$h"
		fi
	done
}

# }}}
# sql {{{

sq() {

	# TODO: sqlite in prod
	# https://fractaledmind.github.io/2023/09/07/enhancing-rails-sqlite-fine-tuning/#pragmas-summary

	# PRAGMA busy_timeout = 5000;
	# PRAGMA cache_size = 2000;
	# PRAGMA journal_mode = WAL;
	# PRAGMA journal_size_limit = 67108864; -- 64 megabytes
	# PRAGMA mmap_size = 134217728; -- 128 megabytes
	# PRAGMA synchronous = NORMAL;

	if [[ -f $1 ]]; then
		< "$2" sqlite3 "$1"
	else
		echo "$2" | sqlite3 "$1"
	fi
	# echo "Not a file: $1"
}

# }}}

# docker {{{

doslow() {
	: list slowest steps in a docker log

	# set -eu
	if
		steps=$(
			< "$1" grep -P '^#\d+ DONE' |
				# sort -k3nr | head -n$n # n slowest steps
				sort -Vu | awk '!a[$1]++' # steps >= 100 secs
		) && [[ -n $steps ]]
	then
		paste <(echo "$steps") <(
			<<< "$steps" cut -d' ' -f1 |
				while read -r n; do
					< "$1" grep "$n" |
						tac |
						grep -Pm1 "$n \[" |
						cut -d' ' -f2-
				done
		)
	else
		echo all ok
	fi
}

docl() {
	sudo docker system prune
	sudo docker volume ls -f dangling=true -q | xargs sudo docker volume rm
}

dostop() {
	docker ps --all --quiet | xargs docker stop
}

dorm() {
	mapfile -t containers < "$(docker ps --all --quiet)"
	docker stop "${containers[@]}"
	docker rm "${containers[@]}"
}

# }}}
# ssh {{{

if [[ -n $REMOTE ]]; then

	sget() {
		if [[ -f $1 ]]; then
			rsync --no-relative --files-from="$1" "$REMOTE:/" .
		else
			rsync --exclude=".*/" "$REMOTE:$1" .
		fi
	}

	sput() {
		rsync --exclude=".*/" "$@" "$REMOTE:~/"
	}

fi

# https://gist.github.com/cmbaughman/6a2ae275e0c0f39f42d95a728e07f796
# https://www.redhat.com/sysadmin/ssh-automation-sshpass

# }}}
# files, navigation {{{

zd() { zip -jr "${1%/}" "${1%/}"; }                         # zip directory (flat); stripping trailing slash is important
zin() { < /dev/stdin zip --junk-paths --names-stdin "$1"; } # pipe files from stdin to zip

f() {
	case $1 in

	n | new | mtime) find "${2:-.}" -maxdepth 1 -type f -printf "%T+\t%p\n" |
		sort |
		cut -f2 ;;

	# https://unix.stackexchange.com/a/22448
	s | sz | size) find "${2:-.}" -type f -exec du -a {} + |
		sort -n ;;

	esac
}

fm() {
	: open file manager with arbitrary args

	if command -v yazi > /dev/null; then
		yazi "$@"
		return
	fi

	# TODO: if glob specified, use that as filter
	# set -x
	_dirs=()
	for x in "$@"; do
		# ranger crashes if a file is passed
		if [[ -d $x ]]; then
			_dirs+=("$x")
		elif [[ -f $x ]]; then
			_dirs+=("$(dirname "$x")")
		fi
	done

	if [[ ${#_dirs[@]} -eq 0 ]]; then
		# echo "No valid paths specified"
		_dirs=(.)
	fi

	if [[ ${#_dirs[@]} -eq 1 ]] && command -v lf > /dev/null; then
		# lf only allows up to 1 arg, but can smartly position cursor
		# on a file; i haven't used lf in forever
		lf "${_dirs[0]}"
	else
		ranger "${_dirs[@]}"
	fi

}

mcd() {
	: mkdir any number of paths, cd to last
	# it is uncommon for >1 arg to be passed, so this is more for cd
	# [[ $# -eq 0 ]] && return
	local p
	for p in "$@"; do mkdir -p "$p" || :; done
	[[ -d $p ]] && cd "$p"
}

if [[ -n $MU ]]; then
	: wrap rm in a python check to prevent accidental deletion of some dir
	rm() {
		# parsing arbitrary args with bash is nonsense

		if [[ $* == *"$MU"* ]]; then
			python3 -c "
import sys
if \"$MU\" in {x.rstrip('/') for x in sys.argv}:
    print('FATAL')
    raise Exception
" $*
		fi

		command rm -v "$@"
	}
fi

rgo() {
	: useful when you know what to look for but dont want to open vim
	# https://blog.burntsushi.net/ripgrep
	# https://github.com/nvim-telescope/telescope.nvim/blob/7b5c5f56a21e82fdcfe5b250278b8dfc4b1cbab4/lua/telescope/config.lua#L646
	# match=$(rg --color=never --no-heading --with-filename --line-number --column --smart-case '^.+$' "${1:-.}" |
	# 	fzf -e)
	# $1 = fzf query generally more useful than $1 = file
	match=$(rg --color=never --no-heading --with-filename --line-number --column --smart-case '^.+$' . |
		fzf -e -q "${1:-}")
	[[ -z $match ]] && return

	# file:line:col:match
	IFS=':' read -ra array <<< "$match"

	# TODO: --glob '!libs/*' (! must be single quoted)

	{
		# force insert into history
		echo "vim $(realpath "${array[0]}")"
		echo "#$(date +%s)"
	} >> ~/.bash_history

	# note: this won't go into history (only rgo will)
	$EDITOR +"${array[1]}" "${array[0]}"

}

j() {
	: jump to frequently used file, should be used in conjunction with rgo
	sel=$(< ~/.bash_history grep -P '^n?vim' |
		awk '!seen[$0]++' |
		while read -r cmd; do
			f=$(<<< "$cmd" cut -d' ' -f2)
			f=$(realpath "$f" 2> /dev/null) || continue
			[[ ! -f $f ]] && continue
			echo "$f"
		done |
		awk '!seen[$0]++' |
		fzf --tac)
	[[ -z $sel ]] && return
	$EDITOR "$sel"
}

# }}}
# stdout manipulation {{{

append() { < /dev/stdin awk '{print $0 "'"$1"'"}'; }
largs() { < /dev/stdin xargs --no-run-if-empty --delimiter='\n' "$@"; } # split xargs by newline instead of space
prepend() { < /dev/stdin awk '{print "'"$1"'" $0}'; }
sum() { < /dev/stdin paste -sd+ | bc; }

jqk() {
	: https://gist.github.com/pedroxs/f0ee8c515eea0dbce2e23eea7c048e10#file-jq-filters-sh-L2
	jq < /dev/stdin -r '.. | objects | with_entries(select(.key | contains("'"$1"'"))) | select(. != {}) | .'"$1"
}

dehtml() {
	# https://stackoverflow.com/a/19878198
	sed < /dev/stdin -e 's/<br[^>]*>/\n/g; s/<[^>]*>//g' |
		# recode xml..utf8 |
		# https://stackoverflow.com/a/13161719
		perl -MHTML::Entities -pe 'decode_entities($_);'
}

yti() {
	: get info for currently playing file with youtube id
	# www-watch?v=bMEfWLA-V00.mp3
	pactl list sink-inputs |
		grep media.name |
		cut -d= -f3 |
		cut -d. -f1 |
		prepend 'https://youtube.com/watch?v=' |
		xargs yt-dlp -j 2> /dev/null |
		jq -r .title
}

# }}}
# web {{{

,c() {
	c "$1" | prettier --parser html
	# c "$1" | lynx -stdin -dump
	# tidy injects extra stuff
}

,,c() {
	# uses a different user agent from curl
	# C() {
	: alternative to curl
	python3 -c '
import codecs
import sys

from bs4 import BeautifulSoup
import cloudscraper

byt = cloudscraper.create_scraper().get(sys.argv[1]).content
s = BeautifulSoup(byt, "html.parser").prettify()

# print(s)

# forcefully decode "unicode-strings" e.g. u002F
print(codecs.decode(s, "unicode-escape"))

' "$1"

}

alias C=,,c

upload() { # upload file to catbox.moe, copy link to clipboard

	# https://github.com/Allypost/bash-scripts/blob/fa4b1006a1c022484c3d48a05ec0ff1c94b9a541/catbox#L116
	# https://github.com/mananapr/dotfiles/blob/9dc9196224c2c84e4265e517dc36af1c79637eb7/bin/catbox
	# https://github.com/search?type=code&q=curl+catbox.moe+language%3AShell+fileupload

	link=$(
		curl -s --form "reqtype=fileupload" \
			--form "fileToUpload=@$1" \
			https://catbox.moe/user/api.php #| tee /dev/null
	)

	echo -en "Uploaded to: \e[1m$link\n" # idk what that escape does
	echo -n "$link" | xclip -sel c
}

nmc() {
	ssid=$(nmcli --terse device wifi list |
		fzf --reverse |
		cut -d: -f8 |
		xargs)
	nmcli --ask device wifi connect "$ssid" # password $password
}

nt() {
	: check network status in a loop
	int=5
	SECONDS=0
	while true; do
		# result=$(timeout 1 ping -c 1 google.com 2> /dev/null)
		# if [[ $? -eq 0 ]]; then
		if ! result=$(timeout 1 ping -c 1 google.com 2> /dev/null); then
			echo -en "\r\e[Kalive $SECONDS"
			notify-send alive
			[[ $int -lt 80 ]] && ((int *= 2))
		else
			# grep <<< "$result" -Po '\d+ ms'
			echo -en '\r\e[Kdead'
			int=5
			SECONDS=0
		fi
		sleep $int
	done
}

getmail() {
	mail 2>&1 | grep 'No new mail.'
	[[ $(notmuch count tag:inbox and tag:unread and date:today) -eq 0 ]] && return
	TERM=xterm-direct neomutt
}

pacmir() {
	: regenerate pacman mirrors
	# TODO: test current speed; if ok, just return
	country=$(curl -sL ipinfo.io | jq -r .country)
	url="https://archlinux.org/mirrorlist/?country=$country&protocol=https&use_mirror_status=on"
	curl -s "$url" |
		sed -e 's/^#Server/Server/' -e '/^#/d' |
		rankmirrors --max-time 1 -v -n 99 - |
		sudo tee /etc/pacman.d/mirrorlist

}

urltitle() {
	wget -qO- "$1" |
		perl -l -0777 -ne 'print $1 if /<title.*?>\s*(.*?)\s*<\/title/si'
}

utm() {
	: urltitle to markdown
	title=$(timeout 3 urltitle "$1")
	[[ -z $title ]] && title=$(awk <<< "$1" -F/ '{print $NF}')
	echo "[$title]($1)"
}

mw() {
	cd ~/.mail/account.gmail || return
	while true; do
		# note: deleting empty dirs will almost certainly break sync
		gmi pull
		new=$(notmuch count tag:inbox and tag:unread and date:today)
		if [[ $new -gt 0 ]]; then
			notify-send -u critical "$new new mail"
			# TODO: neomutt -F? use symlink? (neomuttrc -> neomuttrc_work)
			neomutt
		fi
		sleep 15m
	done
}

# }}}

# ugly funcs that don't warrant a script yet

cm() {
	if [[ $# -eq 0 ]]; then
		chezmoi cd
	else
		chezmoi "$@"
	fi
}

bx() { [[ $# -gt 0 ]] && bash -x "$@"; }
rng() { for _ in $(seq "${2:-1}"); do echo $((1 + RANDOM % ${1:-100})); done; }
ya() { mpv --video=no "ytdl://ytsearch10:\'$*\'"; }
yi() { yt-dlp --dump-single-json --skip-download "$1" 2> /dev/null | jq -r '.title, .description, .webpage_url, .channel_url'; }
yt() { mpv --force-window "ytdl://ytsearch10:\'$*\'"; }

ys() { # read youtube subs in less
	yt-dlp -j "$1" |
		jq . |
		grep '=vtt' |
		grep -v tlang |
		tail -n1 | # auto subs are listed first
		cut -d'"' -f4 |
		xargs curl -sL |
		dehtml |
		grep -v -- '-->' |
		grep -Pv '^\s*$' |
		tr '\n' ' ' |
		fold --spaces |
		less
}

nico() {
	# set -x
	xdotool key super+8
	# ensure window is focused!
	while read -r line; do
		echo "$line" | xclip -sel c
		xdotool key ctrl+2 F6 ctrl+v enter
		sleep 2
	done < "$1"
}

np() {
	pgrep nicotine > /dev/null || return

	while read -r id; do
		# 12 because newline included? whatever
		if [[ $(<<< "$id" wc -c) -eq 12 ]]; then
			title=$(
				echo "$id" |
					prepend http://youtube.com/watch?v= |
					xargs yt-dlp --dump-single-json --skip-download 2> /dev/null |
					jq -r '.title' |
					sed -r '
						s|\([^)]+\)||g
						s|\[[^]]+\]||g
						s|[0-9]{4}.+||g
						s|SW EXCL.+||g
					'
			)
		else
			title=$id
		fi
		echo "$title" | xclip -sel c
		xdotool key super+8 ctrl+2 F6 ctrl+v F6 return
		sleep 2
	done < /tmp/foo
	notify-send 'done'
	rm -iv /tmp/foo

}

# nb() {
# 	: download audio from rss feeds
# 	sort -u -o ~/dita/dita/scrape/discogs.txt{,}
# 	less ~/dita/dita/scrape/discogs.txt
# 	rm ~/dita/dita/scrape/discogs.txt
#
# 	time fetch_rss &&
# 		time ~/dita/ytdl &&
# 		waitdie mpv
# 	vol --auto
# 	mpv --profile=bcx ~/testdir
# 	rm -rI ~/testdir ~/.config/newsboat/cache.txt
# 	np
# }

replace() {
	# mostly for python module refactors
	[[ -d ./.git ]] || git rev-parse --is-inside-work-tree > /dev/null 2>&1 || return

	# check correct rep binary (not the lisp thing)
	if ! command -v rep | grep -F .cargo; then
		return
	fi

	search=$1
	replace=$2
	if ! rg -n -- "$search"; then
		echo "Pattern not found"
		return
	fi
	rg -n -- "$search" | rep -- "$search" "$replace"
	read -r -p 'OK?' || return
	rg -n -- "$search" | rep -w -- "$search" "$replace"
	# if only rep allowed backreferencing the search pattern...
	git diff
	# git add -u
	# git commit -v
}

sd() {
	: shutdown
	# uptime | grep hour || return/reboot

	waitdie mpv pacman curl
	killall firefox

	# TODO: check for any running cron jobs (pstree, tail -f)
	# not running:
	# |-crond
	# |-dbus-daemon

	# pgrep -u $USER cron

	if pgrep nicotine; then
		pid=$(waitdie -s nicotine)
		[[ -n $pid ]] && waitdie -w nicotine
	fi
	# pkill nicotine
	# TODO: if new day (morning), just return
	echo "Shutting down..."
	sleep 3
	# pulseaudio -k
	shutdown now
}

rt() {
	: pass an array of relative paths to tagfix
	# note: dead symlinks are still displayed as if they exist

	larr() {
		# like xargs, but takes a single multi-line arg and turns it into an array
		mapfile -t args < /dev/stdin
		[[ -z ${args[*]} ]] && return # mimic xargs -r
		exec "$1" "${args[@]}" < /dev/tty
	}

	fzf --multi --reverse --preview="ls \"$MU\"/{}" < ~/.config/mpv/library |
		prepend "$MU/" |
		larr fix_tags

}

epk() {
	: check epub validity
	for f in *.epub; do
		if ! unzip -l "$f" > /dev/null 2> /dev/null; then
			echo "$f"
			rm "$f" > /dev/null
		fi
	done | sort >> failed
}

watchmem() {
	stdin="$(< /dev/stdin)"

	if [[ $stdin =~ ^[0-9]+$ ]]; then
		pid="$stdin"
		watch -d ps -o %cpu,%mem,cmd -p "$pid"

	# else
	# 	pid=$(ps aux |
	# 		grep "$1" |
	# 		head -n1 |
	# 		awk '{print $2}')
	# 	while true; do
	# 		pmap -x "$pid" | tail -n1
	# 		sleep 2
	# 	done

	fi

}

gev() {
	: get env var
	find . -type f -name '.*env' -print0 |
		# probably better to force upper, but whatever
		\xargs -0 grep -Pi "$1" |
		awk -F: '!a[$2]++' |
		sed -r 's/:/	/' |
		column -s '	' -t
}

,pgrep() { \pgrep "$1" | xargs ps; }            # ps for runtime
pkill1() { \pgrep "$1" | sed 1d | xargs kill; } # kill all procs except 1st
pk() { pgrep "$1" | fzf -m --tac | cut -d' ' -f1 | xargs kill; }

scan() {
	cd ~/scores || return
	f=$1
	n=1
	echo 'type x to exit'
	res=600
	while true; do
		echo -n "$n: "
		read -r ans < /dev/tty
		[[ $ans == x ]] && break
		# 600: 30 sec, 4.4 MB
		# 2400: 8 min, 48 MB
		scanimage --format=pdf --progress --resolution=$res \
			--output-file "$f-$n-$res.pdf"
		((n++))
	done
	pdfunite $(\ls "$f"-* | sort -V) "$f.pdf"
	rm -I "$f"-*
}

# force delete plugins where contents were unintentionally changed (typically
# via a stray `black` format)
# note: Lazy (still) doesn't have a log file, so the output must be copied from
# Lazy itself
# https://github.com/folke/lazy.nvim/blob/014d1d6d78df4e58f962158e6e00261d8632612c/TODO.md?plain=1#L47
# < lazy.log grep 'local changes in' |
# 	cut -d'`' -f2 |
# 	sort -u |
# 	xargs rm -rf

# note: sendmail unresponsive
# note: it is not known what set up is needed
# echo "$body" | mail --subject="$subject" $email

mdr() {
	c 'https://www.mdr.de/nachrichten/index.html' |
		grep 'class="headline" ' |
		prepend '<li>' |
		html2markdown --domain https://www.mdr.de |
		sort -u
}