@pm-2001/shellup 0.1.0

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@pm-2001/shellup",
+  "version": "0.1.0",
+  "description": "Level up your terminal in 60 seconds — a beautiful prompt, modern tool swaps, and sane defaults, installed by one command and reversible by another.",
+  "keywords": [
+    "terminal",
+    "zsh",
+    "prompt",
+    "cli",
+    "dotfiles",
+    "shell",
+    "developer-experience",
+    "theme",
+    "productivity"
+  ],
+  "homepage": "https://github.com/pm-2001/shell-up#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pm-2001/shell-up.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pm-2001/shell-up/issues"
+  },
+  "license": "MIT",
+  "author": "pm-2001",
+  "type": "module",
+  "bin": {
+    "shellup": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "runtime",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run typecheck && npm run build"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.7.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^26.4.0",
+    "tsup": "^8.5.1",
+    "typescript": "^7.0.2"
+  }
+}

package/runtime/aliases.zsh

@@ -0,0 +1,46 @@
+# shellup — aliases
+# Only aliases that are safe without any extra binary installed. Anything that
+# depends on eza/bat/lazygit lives in generated/tools.zsh behind a guard.
+
+[[ -o interactive ]] || return 0
+
+# ── Navigation ─────────────────────────────────────────────────────────────
+alias ..='cd ..'
+alias ...='cd ../..'
+alias ....='cd ../../..'
+alias -- -='cd -'
+
+# ── Safety rails ───────────────────────────────────────────────────────────
+alias cp='cp -i'
+alias mv='mv -i'
+alias mkdir='mkdir -p'
+
+# ── git ────────────────────────────────────────────────────────────────────
+alias g='git'
+alias gs='git status --short --branch'
+alias ga='git add'
+alias gaa='git add --all'
+alias gc='git commit'
+alias gcm='git commit -m'
+alias gca='git commit --amend'
+alias gco='git checkout'
+alias gsw='git switch'
+alias gb='git branch'
+alias gd='git diff'
+alias gds='git diff --staged'
+alias gp='git push'
+alias gpl='git pull'
+alias gf='git fetch --all --prune'
+alias gst='git stash'
+alias gl='git log --oneline --graph --decorate -20'
+alias gll='git log --oneline --graph --decorate --all'
+alias gundo='git reset --soft HEAD~1'
+alias gwip='git add -A && git commit -m "wip" --no-verify'
+
+# ── Shell housekeeping ─────────────────────────────────────────────────────
+alias reload='exec zsh'
+alias path='print -l $path'
+alias now='date "+%Y-%m-%d %H:%M:%S"'
+alias week='date +%V'
+alias ports='lsof -iTCP -sTCP:LISTEN -P -n'
+alias myip='curl -s https://api.ipify.org && echo'

package/runtime/functions.zsh

@@ -0,0 +1,56 @@
+# shellup — functions
+# The handful of things that are genuinely awkward to type out every time.
+
+[[ -o interactive ]] || return 0
+
+# Make a directory and step into it.
+mkcd() {
+  [[ -z $1 ]] && { print -u2 "usage: mkcd <dir>"; return 2 }
+  mkdir -p -- "$1" && builtin cd -- "$1"
+}
+
+# One command for every archive format, instead of remembering nine flag sets.
+extract() {
+  [[ -z $1 ]] && { print -u2 "usage: extract <archive>"; return 2 }
+  [[ -f $1 ]] || { print -u2 "extract: no such file: $1"; return 1 }
+  case $1 in
+    *.tar.bz2|*.tbz2) tar xjf   -- "$1" ;;
+    *.tar.gz|*.tgz)   tar xzf   -- "$1" ;;
+    *.tar.xz)         tar xJf   -- "$1" ;;
+    *.tar.zst)        tar --zstd -xf -- "$1" ;;
+    *.tar)            tar xf    -- "$1" ;;
+    *.bz2)            bunzip2   -- "$1" ;;
+    *.gz)             gunzip    -- "$1" ;;
+    *.zip)            unzip     -- "$1" ;;
+    *.7z)             7z x         "$1" ;;
+    *.rar)            unrar x      "$1" ;;
+    *.Z)              uncompress -- "$1" ;;
+    *) print -u2 "extract: don't know how to open $1"; return 1 ;;
+  esac
+}
+
+# Serve the current directory over HTTP. `serve 3000` to pick a port.
+serve() {
+  local port=${1:-8000}
+  print "serving $PWD on http://localhost:$port"
+  python3 -m http.server "$port"
+}
+
+# What is holding this port, and what do I kill?
+onport() {
+  [[ -z $1 ]] && { print -u2 "usage: onport <port>"; return 2 }
+  lsof -nP -iTCP:"$1" -sTCP:LISTEN
+}
+
+# Timestamped copy, for when you're about to edit something risky.
+bak() {
+  [[ -z $1 ]] && { print -u2 "usage: bak <file>"; return 2 }
+  cp -a -- "$1" "$1.$(date +%Y%m%d-%H%M%S).bak" && print "backed up $1"
+}
+
+# Jump to the root of the current git repo.
+cdr() {
+  local root
+  root=$(git rev-parse --show-toplevel 2>/dev/null) || { print -u2 "cdr: not in a git repo"; return 1 }
+  builtin cd -- "$root"
+}

package/runtime/keybindings.zsh

@@ -0,0 +1,45 @@
+# shellup — keybindings
+# Emacs bindings plus the two things people miss most: prefix-aware history
+# search on the arrow keys, and word-wise movement that works over ssh.
+
+[[ -o interactive ]] || return 0
+
+bindkey -e
+
+# Type a few characters, press Up: cycles only through matching history.
+autoload -U up-line-or-beginning-search down-line-or-beginning-search
+zle -N up-line-or-beginning-search
+zle -N down-line-or-beginning-search
+bindkey '^[[A' up-line-or-beginning-search      # Up
+bindkey '^[[B' down-line-or-beginning-search    # Down
+bindkey '^[OA' up-line-or-beginning-search      # Up (application mode)
+bindkey '^[OB' down-line-or-beginning-search    # Down (application mode)
+
+bindkey '^[[1;5C' forward-word                  # Ctrl-Right
+bindkey '^[[1;5D' backward-word                 # Ctrl-Left
+bindkey '^[[1;3C' forward-word                  # Alt-Right
+bindkey '^[[1;3D' backward-word                 # Alt-Left
+bindkey '^[f'     forward-word
+bindkey '^[b'     backward-word
+
+bindkey '^[[H' beginning-of-line                # Home
+bindkey '^[[F' end-of-line                      # End
+bindkey '^[[3~' delete-char                     # Delete
+bindkey '^[[3;5~' kill-word                     # Ctrl-Delete
+
+bindkey '^U' backward-kill-line                 # match bash: kill to start, not whole line
+bindkey '^[^?' backward-kill-word               # Alt-Backspace
+
+# Treat path separators as word boundaries so Ctrl-W deletes one path segment.
+WORDCHARS='*?_-.[]~&;!#$%^(){}<>'
+
+# Ctrl-Z again to foreground the job you just suspended.
+_shellup_fg() {
+  if [[ $#BUFFER -eq 0 ]]; then
+    fg >/dev/null 2>&1 && zle redisplay
+  else
+    zle push-input
+  fi
+}
+zle -N _shellup_fg
+bindkey '^Z' _shellup_fg

package/runtime/options.zsh

@@ -0,0 +1,59 @@
+# shellup — zsh defaults
+# Stock zsh forgets history across panes, re-asks for completions it already
+# knows, and makes you type `cd`. These are the settings most people end up
+# copying from a blog post eventually.
+
+[[ -o interactive ]] || return 0
+
+# ── History ────────────────────────────────────────────────────────────────
+HISTFILE="${HISTFILE:-$HOME/.zsh_history}"
+HISTSIZE=100000
+SAVEHIST=100000
+setopt append_history          # never truncate another shell's writes
+setopt inc_append_history      # write as you go, not just on exit
+setopt share_history           # new panes see what you just ran
+setopt hist_ignore_dups
+setopt hist_ignore_all_dups
+setopt hist_ignore_space       # a leading space keeps it out of history
+setopt hist_reduce_blanks
+setopt hist_verify             # expand !! for review instead of running it
+setopt extended_history
+
+# ── Navigation ─────────────────────────────────────────────────────────────
+setopt auto_cd                 # `../..` instead of `cd ../..`
+setopt auto_pushd              # every cd builds a stack; `cd -<TAB>` to browse
+setopt pushd_ignore_dups
+setopt pushd_silent
+DIRSTACKSIZE=20
+
+# ── Globbing & misc ────────────────────────────────────────────────────────
+setopt extended_glob
+setopt no_case_glob
+setopt interactive_comments    # `# note` is legal at the prompt
+setopt no_beep
+setopt no_flow_control         # frees Ctrl-S / Ctrl-Q for real bindings
+unsetopt correct_all           # autocorrect guesses wrong more than it helps
+
+# ── Completion ─────────────────────────────────────────────────────────────
+# compinit rebuilds its cache on every launch unless told otherwise; checking
+# the dump's age once a day keeps startup fast without going stale.
+autoload -Uz compinit
+() {
+  local dump="${ZDOTDIR:-$HOME}/.zcompdump"
+  if [[ -n ${dump}(#qN.mh+24) ]]; then
+    compinit -d "$dump"
+  else
+    compinit -C -d "$dump"
+  fi
+}
+
+zstyle ':completion:*' menu select
+zstyle ':completion:*' matcher-list 'm:{a-zA-Z}={A-Za-z}' 'r:|[._-]=* r:|=*'
+zstyle ':completion:*' list-colors "${(s.:.)LS_COLORS}"
+zstyle ':completion:*' group-name ''
+zstyle ':completion:*:descriptions' format '%F{242}%d%f'
+zstyle ':completion:*:warnings'     format '%F{red}no matches%f'
+zstyle ':completion:*' use-cache on
+zstyle ':completion:*' cache-path "${XDG_CACHE_HOME:-$HOME/.cache}/zsh/compcache"
+zstyle ':completion:*' special-dirs true
+zstyle ':completion:*:*:kill:*:processes' list-colors '=(#b) #([0-9]#)*=0=01;31'

package/runtime/prompt.zsh

@@ -0,0 +1,161 @@
+# shellup — prompt engine
+#
+# The expensive part of a git prompt is `git status` in a large repo. Doing that
+# synchronously is what makes themed prompts feel sluggish, so here the only
+# blocking work per prompt is a single `git rev-parse`; counts, divergence and
+# stash state are computed in a background process that repaints the prompt when
+# it lands. Themes never touch any of this — they read the SHELLUP_* variables
+# and define shellup_theme_render to format them.
+
+[[ -o interactive ]] || return 0
+
+autoload -Uz add-zsh-hook
+setopt prompt_subst
+
+# Overridden by whichever theme file loads next. Defined here so a missing or
+# broken theme degrades to a plain prompt instead of erroring on every line.
+shellup_theme_render() { SHELLUP_GIT_PROMPT=""; }
+
+typeset -g SHELLUP_GIT_ROOT="" SHELLUP_GIT_BRANCH="" SHELLUP_GIT_ACTION=""
+typeset -gi SHELLUP_GIT_STAGED=0 SHELLUP_GIT_UNSTAGED=0 SHELLUP_GIT_UNTRACKED=0
+typeset -gi SHELLUP_GIT_CONFLICTED=0 SHELLUP_GIT_AHEAD=0 SHELLUP_GIT_BEHIND=0
+typeset -gi SHELLUP_GIT_STASH=0 SHELLUP_GIT_LOADING=0
+typeset -g SHELLUP_GIT_PROMPT="" SHELLUP_DURATION="" SHELLUP_VENV=""
+typeset -gi _shellup_async_fd=0 _shellup_timer=0
+
+: ${SHELLUP_SLOW_THRESHOLD:=3}
+
+_shellup_git_reset() {
+  SHELLUP_GIT_ROOT=""; SHELLUP_GIT_BRANCH=""; SHELLUP_GIT_ACTION=""
+  SHELLUP_GIT_STAGED=0; SHELLUP_GIT_UNSTAGED=0; SHELLUP_GIT_UNTRACKED=0
+  SHELLUP_GIT_CONFLICTED=0; SHELLUP_GIT_AHEAD=0; SHELLUP_GIT_BEHIND=0
+  SHELLUP_GIT_STASH=0; SHELLUP_GIT_LOADING=0; SHELLUP_GIT_PROMPT=""
+}
+
+# Runs in a background process. Prints one space-separated line; "-" means empty,
+# so every field stays at a fixed position and the reader needs no parsing rules.
+_shellup_git_worker() {
+  builtin cd -q "$1" 2>/dev/null || return
+  local line xy branch="-" action="-" rest
+  local -i staged=0 unstaged=0 untracked=0 conflicted=0 ahead=0 behind=0 stash=0
+
+  while IFS= read -r line; do
+    case $line in
+      '# branch.head '*) branch=${line#'# branch.head '} ;;
+      '# branch.ab '*)
+        rest=${line#'# branch.ab '}
+        ahead=${${rest%% *}#+}
+        behind=${${rest##* }#-}
+        ;;
+      '? '*) (( untracked += 1 )) ;;
+      'u '*) (( conflicted += 1 )) ;;
+      [12]' '*)
+        xy=${line[3,4]}                       # porcelain v2: X=index, Y=worktree
+        [[ ${xy[1]} != '.' ]] && (( staged += 1 ))
+        [[ ${xy[2]} != '.' ]] && (( unstaged += 1 ))
+        ;;
+    esac
+  done < <(command git status --porcelain=v2 --branch --untracked-files=normal 2>/dev/null)
+
+  stash=$(command git rev-list --walk-reflogs --count refs/stash 2>/dev/null) || stash=0
+  [[ -z $stash ]] && stash=0
+
+  local gitdir
+  gitdir=$(command git rev-parse --git-dir 2>/dev/null)
+  if [[ -n $gitdir ]]; then
+    if   [[ -d $gitdir/rebase-merge || -d $gitdir/rebase-apply ]]; then action="rebase"
+    elif [[ -f $gitdir/MERGE_HEAD ]];       then action="merge"
+    elif [[ -f $gitdir/CHERRY_PICK_HEAD ]]; then action="cherry-pick"
+    elif [[ -f $gitdir/REVERT_HEAD ]];      then action="revert"
+    elif [[ -f $gitdir/BISECT_LOG ]];       then action="bisect"
+    fi
+  fi
+
+  [[ $branch == '(detached)' ]] && branch="@$(command git rev-parse --short HEAD 2>/dev/null)"
+  print -r -- "$staged $unstaged $untracked $conflicted $ahead $behind $stash $action $branch"
+}
+
+_shellup_async_stop() {
+  (( _shellup_async_fd )) || return 0
+  zle -F $_shellup_async_fd 2>/dev/null
+  exec {_shellup_async_fd}<&- 2>/dev/null
+  _shellup_async_fd=0
+}
+
+# Fired by zle when the worker has written its line (or hung up).
+_shellup_async_callback() {
+  local fd=$1 data
+  IFS= read -r data <&$fd
+  zle -F $fd 2>/dev/null
+  exec {fd}<&- 2>/dev/null
+  _shellup_async_fd=0
+  SHELLUP_GIT_LOADING=0
+
+  if [[ -n $data ]]; then
+    local -a f=( ${=data} )
+    SHELLUP_GIT_STAGED=$f[1];     SHELLUP_GIT_UNSTAGED=$f[2]
+    SHELLUP_GIT_UNTRACKED=$f[3];  SHELLUP_GIT_CONFLICTED=$f[4]
+    SHELLUP_GIT_AHEAD=$f[5];      SHELLUP_GIT_BEHIND=$f[6]
+    SHELLUP_GIT_STASH=$f[7]
+    [[ $f[8] != '-' ]] && SHELLUP_GIT_ACTION=$f[8] || SHELLUP_GIT_ACTION=""
+    [[ $f[9] != '-' ]] && SHELLUP_GIT_BRANCH=$f[9]
+  fi
+
+  shellup_theme_render
+  zle && zle reset-prompt
+}
+
+_shellup_preexec() {
+  _shellup_timer=$EPOCHSECONDS
+}
+
+_shellup_precmd() {
+  # Command duration, surfaced only when it was long enough to care about.
+  SHELLUP_DURATION=""
+  if (( _shellup_timer )); then
+    local -i elapsed=$(( EPOCHSECONDS - _shellup_timer ))
+    if (( elapsed >= SHELLUP_SLOW_THRESHOLD )); then
+      if   (( elapsed < 60 ));   then SHELLUP_DURATION="${elapsed}s"
+      elif (( elapsed < 3600 )); then SHELLUP_DURATION="$(( elapsed / 60 ))m$(( elapsed % 60 ))s"
+      else                            SHELLUP_DURATION="$(( elapsed / 3600 ))h$(( (elapsed % 3600) / 60 ))m"
+      fi
+    fi
+    _shellup_timer=0
+  fi
+
+  SHELLUP_VENV=""
+  [[ -n $VIRTUAL_ENV ]] && SHELLUP_VENV=${VIRTUAL_ENV:t}
+
+  _shellup_async_stop
+
+  # The one synchronous git call: cheap even in a huge repo.
+  local -a info
+  info=( ${(f)"$(command git rev-parse --show-toplevel --abbrev-ref HEAD 2>/dev/null)"} )
+  if (( ${#info} < 2 )); then
+    _shellup_git_reset
+    shellup_theme_render
+    return
+  fi
+
+  local root=$info[1] branch=$info[2]
+  # rev-parse still prints the toplevel on an unborn branch but resolves HEAD to
+  # the literal string "HEAD"; a detached checkout does the same. Git forbids a
+  # branch actually named HEAD, so this is an unambiguous signal to look closer.
+  if [[ $branch == HEAD ]]; then
+    branch=$(command git symbolic-ref --short HEAD 2>/dev/null) \
+      || branch="@$(command git rev-parse --short HEAD 2>/dev/null)"
+  fi
+  # Leaving a repo must clear counts, or the old repo's state bleeds into the new prompt.
+  [[ $root != $SHELLUP_GIT_ROOT ]] && _shellup_git_reset
+  SHELLUP_GIT_ROOT=$root
+  SHELLUP_GIT_BRANCH=$branch
+  SHELLUP_GIT_LOADING=1
+  shellup_theme_render
+
+  exec {_shellup_async_fd}< <( _shellup_git_worker "$root" )
+  zle -F $_shellup_async_fd _shellup_async_callback
+}
+
+zmodload zsh/datetime 2>/dev/null
+add-zsh-hook preexec _shellup_preexec
+add-zsh-hook precmd  _shellup_precmd

package/runtime/themes/minimal.zsh

@@ -0,0 +1,29 @@
+# shellup theme: minimal
+# Deliberately glyph-free — every character here exists in any monospace font,
+# so this is the theme that is always safe to fall back to.
+
+typeset -g SHELLUP_CTX_PROMPT=""
+
+shellup_theme_render() {
+  local s=""
+  if [[ -n $SHELLUP_GIT_BRANCH ]]; then
+    s=" %F{242}on%f %F{magenta}${SHELLUP_GIT_BRANCH}%f"
+    (( SHELLUP_GIT_STAGED ))     && s+=" %F{green}+${SHELLUP_GIT_STAGED}%f"
+    (( SHELLUP_GIT_UNSTAGED ))   && s+=" %F{yellow}!${SHELLUP_GIT_UNSTAGED}%f"
+    (( SHELLUP_GIT_UNTRACKED ))  && s+=" %F{blue}?${SHELLUP_GIT_UNTRACKED}%f"
+    (( SHELLUP_GIT_CONFLICTED )) && s+=" %F{red}x${SHELLUP_GIT_CONFLICTED}%f"
+    (( SHELLUP_GIT_STASH ))      && s+=" %F{cyan}*${SHELLUP_GIT_STASH}%f"
+    (( SHELLUP_GIT_AHEAD ))      && s+=" %F{cyan}^${SHELLUP_GIT_AHEAD}%f"
+    (( SHELLUP_GIT_BEHIND ))     && s+=" %F{cyan}v${SHELLUP_GIT_BEHIND}%f"
+    [[ -n $SHELLUP_GIT_ACTION ]] && s+=" %F{red}(${SHELLUP_GIT_ACTION})%f"
+  fi
+  SHELLUP_GIT_PROMPT=$s
+
+  local ctx=""
+  [[ -n $SHELLUP_VENV ]] && ctx=" %F{yellow}(${SHELLUP_VENV})%f"
+  SHELLUP_CTX_PROMPT=$ctx
+}
+
+PROMPT='%F{39}%(4~|…/%3~|%~)%f${SHELLUP_GIT_PROMPT}${SHELLUP_CTX_PROMPT}
+%(?.%F{green}.%F{red})>%f '
+RPROMPT='%F{242}${SHELLUP_DURATION}%f%(?.. %F{red}[%?]%f)'

package/runtime/themes/neon.zsh

@@ -0,0 +1,29 @@
+# shellup theme: neon
+# Bright two-line prompt drawn with box characters and common Unicode arrows —
+# no patched font required, so it works next to minimal on a bare system.
+
+typeset -g SHELLUP_CTX_PROMPT=""
+
+shellup_theme_render() {
+  local s=""
+  if [[ -n $SHELLUP_GIT_BRANCH ]]; then
+    s=" %F{240}·%f %F{213}⌥ ${SHELLUP_GIT_BRANCH}%f"
+    (( SHELLUP_GIT_STAGED ))     && s+=" %F{82}●${SHELLUP_GIT_STAGED}%f"
+    (( SHELLUP_GIT_UNSTAGED ))   && s+=" %F{220}✚${SHELLUP_GIT_UNSTAGED}%f"
+    (( SHELLUP_GIT_UNTRACKED ))  && s+=" %F{45}◌${SHELLUP_GIT_UNTRACKED}%f"
+    (( SHELLUP_GIT_CONFLICTED )) && s+=" %F{196}✖${SHELLUP_GIT_CONFLICTED}%f"
+    (( SHELLUP_GIT_STASH ))      && s+=" %F{141}⚑${SHELLUP_GIT_STASH}%f"
+    (( SHELLUP_GIT_AHEAD ))      && s+=" %F{51}⇡${SHELLUP_GIT_AHEAD}%f"
+    (( SHELLUP_GIT_BEHIND ))     && s+=" %F{51}⇣${SHELLUP_GIT_BEHIND}%f"
+    [[ -n $SHELLUP_GIT_ACTION ]] && s+=" %F{196}⚡${SHELLUP_GIT_ACTION}%f"
+  fi
+  SHELLUP_GIT_PROMPT=$s
+
+  local ctx=""
+  [[ -n $SHELLUP_VENV ]] && ctx=" %F{240}·%f %F{184}🐍${SHELLUP_VENV}%f"
+  SHELLUP_CTX_PROMPT=$ctx
+}
+
+PROMPT='%F{240}╭─%f %F{51}%(4~|…/%3~|%~)%f${SHELLUP_GIT_PROMPT}${SHELLUP_CTX_PROMPT}
+%F{240}╰─%f%(?.%F{213}.%F{196})❯%f '
+RPROMPT='%F{240}${SHELLUP_DURATION}%f%(?.. %F{196}✖ %?%f)'

package/runtime/themes/powerline.zsh

@@ -0,0 +1,36 @@
+# shellup theme: powerline
+# Requires a Nerd Font — the separators and icons below are private-use glyphs
+# and render as tofu boxes without one. `shellup doctor` checks for this.
+
+typeset -g SHELLUP_CTX_PROMPT=""
+
+shellup_theme_render() {
+  local s=""
+  if [[ -n $SHELLUP_GIT_BRANCH ]]; then
+    local body=" ${SHELLUP_GIT_BRANCH}"
+    (( SHELLUP_GIT_STAGED ))     && body+=" +${SHELLUP_GIT_STAGED}"
+    (( SHELLUP_GIT_UNSTAGED ))   && body+=" !${SHELLUP_GIT_UNSTAGED}"
+    (( SHELLUP_GIT_UNTRACKED ))  && body+=" ?${SHELLUP_GIT_UNTRACKED}"
+    (( SHELLUP_GIT_CONFLICTED )) && body+=" ${SHELLUP_GIT_CONFLICTED}"
+    (( SHELLUP_GIT_STASH ))      && body+=" ${SHELLUP_GIT_STASH}"
+    (( SHELLUP_GIT_AHEAD ))      && body+=" ⇡${SHELLUP_GIT_AHEAD}"
+    (( SHELLUP_GIT_BEHIND ))     && body+=" ⇣${SHELLUP_GIT_BEHIND}"
+    [[ -n $SHELLUP_GIT_ACTION ]] && body+="  ${SHELLUP_GIT_ACTION}"
+
+    # Dirty tree turns the segment amber; clean stays green.
+    local bg=71
+    (( SHELLUP_GIT_UNSTAGED + SHELLUP_GIT_UNTRACKED + SHELLUP_GIT_CONFLICTED )) && bg=178
+    s="%K{$bg}%F{24}%f%F{233}${body} %f%k%F{$bg}%f"
+  else
+    s="%F{24}%f"
+  fi
+  SHELLUP_GIT_PROMPT=$s
+
+  local ctx=""
+  [[ -n $SHELLUP_VENV ]] && ctx=" %F{184} ${SHELLUP_VENV}%f"
+  SHELLUP_CTX_PROMPT=$ctx
+}
+
+PROMPT='%K{24}%F{233} %(4~|…/%3~|%~) %f%k${SHELLUP_GIT_PROMPT}${SHELLUP_CTX_PROMPT}
+%(?.%F{71}.%F{160})❯%f '
+RPROMPT='%F{240}${SHELLUP_DURATION}%f%(?.. %F{160} %?%f)'