gh() {

# gh repo adduser "$COLLABORATOR" "$PROJECT_NAME"

if [[ $1 == "repo" && $2 == "adduser" ]]; then

gh api --method=PUT "repos/$GITHUB_USER/$4/collaborators/$3"

else

command gh "$@";

fi

}

function y() {

local tmp="$(mktemp -t "yazi-cwd.XXXXXX")" cwd

yazi "$@" --cwd-file="$tmp"

if cwd="$(command cat -- "$tmp")" && [ -n "$cwd" ] && [ "$cwd" != "$PWD" ]; then

builtin cd -- "$cwd"

fi

rm -f -- "$tmp"

}

ghcs() {

FUNCNAME="$funcstack[1]"

TARGET="shell"

local GH_DEBUG="$GH_DEBUG"

local GH_HOST="$GH_HOST"

read -r -d '' __USAGE <<-EOF

Wrapper around \`gh copilot suggest\` to suggest a command based on a natural language description of the desired output effort.

Supports executing suggested commands if applicable.

USAGE

$FUNCNAME [flags] <prompt>

FLAGS

-d, --debug Enable debugging

-h, --help Display help usage

--hostname The GitHub host to use for authentication

-t, --target target Target for suggestion; must be shell, gh, git

default: "$TARGET"

EXAMPLES

- Guided experience

$ $FUNCNAME

- Git use cases

$ $FUNCNAME -t git "Undo the most recent local commits"

$ $FUNCNAME -t git "Clean up local branches"

$ $FUNCNAME -t git "Setup LFS for images"

- Working with the GitHub CLI in the terminal

$ $FUNCNAME -t gh "Create pull request"

$ $FUNCNAME -t gh "List pull requests waiting for my review"

$ $FUNCNAME -t gh "Summarize work I have done in issues and pull requests for promotion"

- General use cases

$ $FUNCNAME "Kill processes holding onto deleted files"

$ $FUNCNAME "Test whether there are SSL/TLS issues with github.com"

$ $FUNCNAME "Convert SVG to PNG and resize"

$ $FUNCNAME "Convert MOV to animated PNG"

EOF

local OPT OPTARG OPTIND

while getopts "dht:-:" OPT; do

if [ "$OPT" = "-" ]; then # long option: reformulate OPT and OPTARG

OPT="${OPTARG%%=*}" # extract long option name

OPTARG="${OPTARG#"$OPT"}" # extract long option argument (may be empty)

OPTARG="${OPTARG#=}" # if long option argument, remove assigning `=`

fi

case "$OPT" in

debug | d)

GH_DEBUG=api

;;

help | h)

echo "$__USAGE"

return 0

;;

hostname)

GH_HOST="$OPTARG"

;;

target | t)

TARGET="$OPTARG"

;;

esac

done

# shift so that $@, $1, etc. refer to the non-option arguments

shift "$((OPTIND-1))"

TMPFILE="$(mktemp -t gh-copilotXXXXXX)"

trap 'rm -f "$TMPFILE"' EXIT

if GH_DEBUG="$GH_DEBUG" GH_HOST="$GH_HOST" gh copilot suggest -t "$TARGET" "$@" --shell-out "$TMPFILE"; then

if [ -s "$TMPFILE" ]; then

FIXED_CMD="$(cat $TMPFILE)"

print -s "$FIXED_CMD"

echo

eval "$FIXED_CMD"

fi

else

return 1

fi

}

ghce() {

FUNCNAME="$funcstack[1]"

local GH_DEBUG="$GH_DEBUG"

local GH_HOST="$GH_HOST"

read -r -d '' __USAGE <<-EOF

Wrapper around \`gh copilot explain\` to explain a given input command in natural language.

USAGE

$FUNCNAME [flags] <command>

FLAGS

-d, --debug Enable debugging

-h, --help Display help usage

--hostname The GitHub host to use for authentication

EXAMPLES

# View disk usage, sorted by size

$ $FUNCNAME 'du -sh | sort -h'

# View git repository history as text graphical representation

$ $FUNCNAME 'git log --oneline --graph --decorate --all'

# Remove binary objects larger than 50 megabytes from git history

$ $FUNCNAME 'bfg --strip-blobs-bigger-than 50M'

EOF

local OPT OPTARG OPTIND

while getopts "dh-:" OPT; do

if [ "$OPT" = "-" ]; then # long option: reformulate OPT and OPTARG

OPT="${OPTARG%%=*}" # extract long option name

OPTARG="${OPTARG#"$OPT"}" # extract long option argument (may be empty)

OPTARG="${OPTARG#=}" # if long option argument, remove assigning `=`

fi

case "$OPT" in

debug | d)

GH_DEBUG=api

;;

help | h)

echo "$__USAGE"

return 0

;;

hostname)

GH_HOST="$OPTARG"

;;

esac

done

# shift so that $@, $1, etc. refer to the non-option arguments

shift "$((OPTIND-1))"

GH_DEBUG="$GH_DEBUG" GH_HOST="$GH_HOST" gh copilot explain "$@"

}

# list/describe ec2 instances in all the regions

function ec2-list-all(){

for region in `aws ec2 describe-regions --output text | cut -f3`

do

echo -e "\nListing Instances in region:'$region'..."

echo -e "https://console.aws.amazon.com/ec2/v2/home?region=$region"

aws ec2 describe-instances --region $region | jq '.Reservations[] | ( .Instances[] | {state: .State.Name, name: .KeyName, type: .InstanceType, key: .KeyName})'

done

}

function svg-to-base64() {

echo "background: transparent url('data:image/svg+xml;base64,"$(openssl base64 < $@)"') no-repeat center center;"

}

function dj() {

# finds manage.py in sub-directories and passes the arguments to it for running via it.

# e.g. dj migrate

# dj runserver

# dj collectstatic --noinput

find . -maxdepth 2 -name 'manage.py' -exec python "{}" "$@" \;

}

function chpwd() {

emulate -L zsh

if [[ -e venv/bin/activate ]]; then

source venv/bin/activate

fi

}

# ------------------------------------------------------------------------------

# | Openssl |

# ------------------------------------------------------------------------------

openssl-to-pem () {

openssl pkcs12 -in $1 -out $1.pem -nodes -clcerts

}

# ------------------------------------------------------------------------------

# | File System |

# ------------------------------------------------------------------------------

# Create a data URI from a file

datauri() {

local mimeType=""

if [ -f "$1" ]; then

mimeType=$(file -b --mime-type "$1")

# └─ do not prepend the filename to the output

if [[ $mimeType == text/* ]]; then

mimeType="$mimeType;charset=utf-8"

fi

printf "data:%s;base64,%s" \

"$mimeType" \

"$(openssl base64 -in "$1" | tr -d "\n")"

else

print_error "'$1' is not a file."

fi

}

# Monitor IO in real-time (open files etc).

function openfiles() {

sudo dtrace -n 'syscall::open*:entry { printf("%s %s",execname,copyinstr(arg0)); }'

}

# copy the work directory to clipboard

function pwdc() {

pwd | tr -d "\r\n" | pbcopy

}

# touch a file while creating directories

supertouch() {

if [ $# -lt 1 ]; then

echo "Missing argument";

return 1;

fi

for f in "$@"; do

mkdir -p -- "$(dirname -- "$f")"

touch -- "$f"

done

}

# Create a .tar.gz archive, using `zopfli`, `pigz` or `gzip` for compression

function targz() {

local tmpFile="${@%/}.tar"

tar -cvf "${tmpFile}" --exclude=".DS_Store" "${@}" || return 1

size=$(

stat -f"%z" "${tmpFile}" 2> /dev/null; # OS X `stat`

stat -c"%s" "${tmpFile}" 2> /dev/null # GNU `stat`

)

local cmd=""

if (( size < 52428800 )) && hash zopfli 2> /dev/null; then

# the .tar file is smaller than 50 MB and Zopfli is available; use it

cmd="zopfli"

else

if hash pigz 2> /dev/null; then

cmd="pigz"

else

cmd="gzip"

fi

fi

echo "Compressing .tar using \`${cmd}\`…"

"${cmd}" -v "${tmpFile}" || return 1

[ -f "${tmpFile}" ] && rm "${tmpFile}"

echo "${tmpFile}.gz created successfully."

}

# Helper for extracting archives

function x () {

case "$1" in

*.tar*)

tar xvf "$1"

;;

*.zip)

unzip "$1"

;;

esac

}

# tiny helpers

function l () {

case "$1" in

recent)

shift

ls -vtl "$@" | head -n 10

;;

size)

shift

ls -vSl "$@"

;;

*) ls -vl "$@"

;;

esac

}

# Determine size of a file or total size of a directory

fs() {

if du -b /dev/null > /dev/null 2>&1; then

local arg=-sbh

else

local arg=-sh

fi

# shellcheck disable=SC2199

if [[ -n "$@" ]]; then

du $arg -- "$@"

else

du $arg -- .[^.]* *

fi

}

# Syntax-highlight JSON strings or files

# Usage: `json '{"foo":42}'` or `echo '{"foo":42}' | json`

function json() {

if [ -t 0 ]; then # argument

python -mjson.tool <<< "$*" | pygmentize -l javascript

else # pipe

python -mjson.tool | pygmentize -l javascript

fi

}

# Recursively convert CRLF to LF in non-binary files under the current directory

# Assumes perl installed

function fixcrlf(){

find . -type f -exec grep -qIP '\r\n' {} ';' -exec perl -pi -e 's/\r\n/\n/g' {} '+'

}

# Create new directories and enter the first one

function md() {

mkdir -pv "$@" && cd "$1"

}

# Make a temporary directory and enter it

tmpd() {

local dir

if [ $# -eq 0 ]; then

dir=$(mktemp -d)

else

dir=$(mktemp -d -t "${1}.XXXXXXXXXX")

fi

cd "$dir" || exit

}

# Copy w/ progress

cp_p () {

rsync -WavP --human-readable --progress $1 $2

}

# ------------------------------------------------------------------------------

# | Network |

# ------------------------------------------------------------------------------

# Display http headers of a request

function headers(){

curl -sI "$@"

}

# Test if HTTP compression (RFC 2616 + SDCH) is enabled for a given URL.

# Send a fake UA string for sites that sniff it instead of using the Accept-Encoding header. (Looking at you, ajax.googleapis.com!)

function httpcompression() {

encoding="$(curl -LIs -H 'User-Agent: Mozilla/5 Gecko' -H 'Accept-Encoding: gzip,deflate,compress,sdch' "$1" | grep '^Content-Encoding:')" && echo "$1 is encoded using ${encoding#* }" || echo "$1 is not using any encoding"

}

# Start an HTTP server from a directory, optionally specifying the port

function server() {

local port="${1:-8000}"

sleep 1 && open "http://localhost:${port}/" &

python3 -m http.server "$port"

}

# Start a PHP server from a directory, optionally specifying the port

# (Requires PHP 5.4.0+.)

function phpserver() {

local port="${1:-4000}"

sleep 1 && open "http://localhost:${port}/" &

php -S "localhost:${port}"

}

# ------------------------------------------------------------------------------

# | Git |

# ------------------------------------------------------------------------------

# function to normalize a crupt git repo

function git_normalize_eol(){

echo "* text=auto" >>.gitattributes

rm .git/index # Remove the index to force git to

git reset # re-scan the working directory

git status # Show files that will be normalized

git add -u

git add .gitattributes

git commit -m "fix(git): introduce end-of-line normalization"

}

function gitignore() {

curl -s https://www.gitignore.io/api/$@;

}

# take this repo and copy it to somewhere else minus the .git stuff.

function gitexport(){

mkdir -p "$1"

git archive master | tar -x -C "$1"

}

# A better way to do git clone

function clone() {

url=$1;

reponame=$(echo $url | awk -F/ '{print $NF}' | sed -e 's/.git$//');

git clone $url $reponame;

cd $reponame;

s .

}