syntaur 0.4.0 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "syntaur",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Project workflow CLI with dashboard, Claude Code plugin, and Codex plugin",
   "homepage": "https://github.com/prong-horn/syntaur#readme",
   "repository": {
@@ -54,6 +54,7 @@
     "node": ">=20.0.0"
   },
   "dependencies": {
+    "@inquirer/prompts": "^8.4.2",
     "better-sqlite3": "^11.0.0",
     "chokidar": "^4.0.0",
     "commander": "^13.0.0",

package/statusline/statusline.sh

@@ -1,62 +1,102 @@
 #!/usr/bin/env bash
 # Syntaur statusline for Claude Code.
 #
-# Reads JSON from stdin per Claude Code's statusLine contract and prints a
-# single line containing:
-#   [optional: output from a wrapped user script]
-#   <git repo:branch>
-#   <active syntaur assignment>
-#   <sessionId suffix>
+# Reads JSON from stdin per Claude Code's statusLine contract and renders a
+# user-configurable single line composed of the segments listed in
+#   $HOME/.syntaur/statusline.config.json
+# with shape:
+#   { "segments": ["wrap","git","assignment","model","ctx","session"],
+#     "separator": " · ",
+#     "wrap": "/optional/path/to/inner-statusline.sh" }
 #
-# Wrapping: if SYNTAUR_STATUSLINE_WRAP names an executable, or the first
-# non-empty line of $HOME/.syntaur/statusline.conf is a path to an executable,
-# that script is invoked first with the same stdin; its stdout becomes the
-# leading segment. This lets users who already had a custom statusline keep
-# it while composing syntaur's extra info on the right.
+# Available segments:
+#   wrap       stdout of an external script (composes another statusline)
+#   git        repo:branch (+ dirty marker + ahead/behind counts)
+#   assignment active syntaur assignment (project/slug or standalone/uuid — title)
+#   session    Claude session id, last 8 chars prefixed by "…"
+#   model      Claude model display name
+#   ctx        context window fill bar, e.g. "ctx:[####------] 42%"
+#   cwd        basename of the current working directory
 #
+# If the config file is absent, falls back to a sensible default set.
 # Never fails the terminal — always exits 0.
 
 set -o pipefail 2>/dev/null || true
 
 INPUT=$(cat)
 
-# Degrade cleanly if jq is unavailable. Emit just the marker so users notice.
 if ! command -v jq >/dev/null 2>&1; then
   printf '%s' '(syntaur: jq missing)'
   exit 0
 fi
 
+CONFIG_FILE="$HOME/.syntaur/statusline.config.json"
+# Fall back to a simple one-line conf file for backward compat with earlier
+# install-statusline versions that only stored a wrap target.
+LEGACY_CONF="$HOME/.syntaur/statusline.conf"
+
+# --- Load config ---
+SEGMENTS_RAW=""
+SEPARATOR=" · "
+WRAP_PATH=""
+
+if [ -f "$CONFIG_FILE" ]; then
+  SEGMENTS_RAW=$(jq -r '(.segments // []) | join(",")' "$CONFIG_FILE" 2>/dev/null)
+  SEP_FROM_CONF=$(jq -r '.separator // empty' "$CONFIG_FILE" 2>/dev/null)
+  [ -n "$SEP_FROM_CONF" ] && SEPARATOR="$SEP_FROM_CONF"
+  WRAP_PATH=$(jq -r '.wrap // empty' "$CONFIG_FILE" 2>/dev/null)
+fi
+
+# Env var always takes precedence for wrap (useful for testing).
+[ -n "$SYNTAUR_STATUSLINE_WRAP" ] && WRAP_PATH="$SYNTAUR_STATUSLINE_WRAP"
+
+# Legacy conf: first non-empty, non-comment line is wrap path.
+if [ -z "$WRAP_PATH" ] && [ -f "$LEGACY_CONF" ]; then
+  WRAP_PATH=$(awk 'NF && !/^#/{print; exit}' "$LEGACY_CONF" 2>/dev/null)
+fi
+
+# Default segment set if none configured.
+if [ -z "$SEGMENTS_RAW" ]; then
+  # Default: include wrap as leading segment only if a wrap path is set.
+  if [ -n "$WRAP_PATH" ]; then
+    SEGMENTS_RAW="wrap,git,assignment,session"
+  else
+    SEGMENTS_RAW="git,assignment,session"
+  fi
+fi
+
+# --- Extract stdin fields ---
 SESSION_ID=""
 CWD=""
+MODEL=""
+USED_PCT=""
 
 if [ -n "$INPUT" ]; then
   SESSION_ID=$(printf '%s' "$INPUT" | jq -r '.session_id // empty' 2>/dev/null)
   CWD=$(printf '%s' "$INPUT" | jq -r '.workspace.current_dir // .cwd // empty' 2>/dev/null)
+  MODEL=$(printf '%s' "$INPUT" | jq -r '.model.display_name // empty' 2>/dev/null)
+  USED_PCT=$(printf '%s' "$INPUT" | jq -r '.context_window.used_percentage // empty' 2>/dev/null)
 fi
 
 [ -z "$CWD" ] && CWD="$PWD"
 
-# --- Optional wrap: compose with an existing user script ---
-WRAP_PATH="${SYNTAUR_STATUSLINE_WRAP:-}"
-if [ -z "$WRAP_PATH" ] && [ -f "$HOME/.syntaur/statusline.conf" ]; then
-  # First non-empty, non-comment line is the wrap path.
-  WRAP_PATH=$(awk 'NF && !/^#/{print; exit}' "$HOME/.syntaur/statusline.conf" 2>/dev/null)
-fi
-WRAPPED_OUT=""
+# --- Compute each available segment value (cheap, unconditional). ---
+
+# wrap
+WRAP_SEG=""
 if [ -n "$WRAP_PATH" ] && [ -r "$WRAP_PATH" ]; then
-  # Run the wrapped script with the same stdin and a 2-second timeout (best-effort).
   if command -v timeout >/dev/null 2>&1; then
-    WRAPPED_OUT=$(printf '%s' "$INPUT" | timeout 2 bash "$WRAP_PATH" 2>/dev/null)
+    WRAP_SEG=$(printf '%s' "$INPUT" | timeout 2 bash "$WRAP_PATH" 2>/dev/null)
   else
-    WRAPPED_OUT=$(printf '%s' "$INPUT" | bash "$WRAP_PATH" 2>/dev/null)
+    WRAP_SEG=$(printf '%s' "$INPUT" | bash "$WRAP_PATH" 2>/dev/null)
   fi
-  # Collapse any trailing newlines so the composed line stays single-row.
-  WRAPPED_OUT=$(printf '%s' "$WRAPPED_OUT" | tr -d '\r' | awk 'NF{line=$0} END{print line}' 2>/dev/null)
+  # Take last non-empty line (collapse to single row).
+  WRAP_SEG=$(printf '%s' "$WRAP_SEG" | tr -d '\r' | awk 'NF{line=$0} END{print line}' 2>/dev/null)
 fi
 
-# --- Segment: git repo:branch ---
+# git — repo:branch[*] +ahead -behind
 GIT_SEG=""
-if [ -n "$CWD" ] && [ -d "$CWD" ]; then
+if [ -d "$CWD" ]; then
   GIT_ROOT=$(git --no-optional-locks -C "$CWD" rev-parse --show-toplevel 2>/dev/null)
   if [ -n "$GIT_ROOT" ]; then
     REPO=$(basename "$GIT_ROOT")
@@ -65,34 +105,47 @@ if [ -n "$CWD" ] && [ -d "$CWD" ]; then
       SHORT=$(git --no-optional-locks -C "$CWD" rev-parse --short HEAD 2>/dev/null)
       [ -n "$SHORT" ] && BRANCH="detached@$SHORT"
     fi
+
+    DIRTY=""
+    if ! git --no-optional-locks -C "$CWD" diff --quiet 2>/dev/null \
+       || ! git --no-optional-locks -C "$CWD" diff --cached --quiet 2>/dev/null; then
+      DIRTY="*"
+    fi
+
+    AHEAD_BEHIND=""
+    UPSTREAM=$(git --no-optional-locks -C "$CWD" rev-parse --abbrev-ref --symbolic-full-name "@{u}" 2>/dev/null)
+    if [ -n "$UPSTREAM" ]; then
+      AHEAD=$(git --no-optional-locks -C "$CWD" rev-list --count "$UPSTREAM..HEAD" 2>/dev/null)
+      BEHIND=$(git --no-optional-locks -C "$CWD" rev-list --count "HEAD..$UPSTREAM" 2>/dev/null)
+      [ "${AHEAD:-0}" -gt 0 ] 2>/dev/null  && AHEAD_BEHIND=" +${AHEAD}"
+      [ "${BEHIND:-0}" -gt 0 ] 2>/dev/null && AHEAD_BEHIND="${AHEAD_BEHIND} -${BEHIND}"
+    fi
+
     if [ -n "$BRANCH" ]; then
-      GIT_SEG="$REPO:$BRANCH"
+      GIT_SEG="${REPO}:${BRANCH}${DIRTY}${AHEAD_BEHIND}"
     else
       GIT_SEG="$REPO"
     fi
   fi
 fi
 
-# --- Segment: active syntaur assignment ---
+# assignment — project/slug — title  (or standalone/uuid-prefix — title)
 ASSIGNMENT_SEG=""
 CONTEXT_FILE="$CWD/.syntaur/context.json"
 if [ -f "$CONTEXT_FILE" ]; then
   PROJECT_SLUG=$(jq -r '.projectSlug // empty' "$CONTEXT_FILE" 2>/dev/null)
   ASSIGNMENT_SLUG=$(jq -r '.assignmentSlug // empty' "$CONTEXT_FILE" 2>/dev/null)
   ASSIGNMENT_DIR=$(jq -r '.assignmentDir // empty' "$CONTEXT_FILE" 2>/dev/null)
-
   TITLE=""
   if [ -n "$ASSIGNMENT_DIR" ] && [ -f "$ASSIGNMENT_DIR/assignment.md" ]; then
     TITLE=$(awk '/^title:/{sub(/^title:[[:space:]]*"?/,""); sub(/"?[[:space:]]*$/,""); print; exit}' "$ASSIGNMENT_DIR/assignment.md" 2>/dev/null)
   fi
-
   LABEL=""
   if [ -n "$PROJECT_SLUG" ] && [ -n "$ASSIGNMENT_SLUG" ]; then
     LABEL="$PROJECT_SLUG/$ASSIGNMENT_SLUG"
   elif [ -n "$ASSIGNMENT_SLUG" ]; then
     LABEL="standalone/${ASSIGNMENT_SLUG:0:8}"
   fi
-
   if [ -n "$LABEL" ] && [ -n "$TITLE" ]; then
     ASSIGNMENT_SEG="$LABEL — $TITLE"
   elif [ -n "$LABEL" ]; then
@@ -100,7 +153,7 @@ if [ -f "$CONTEXT_FILE" ]; then
   fi
 fi
 
-# --- Segment: session id suffix ---
+# session — last 8 chars
 SESSION_SEG=""
 if [ -n "$SESSION_ID" ]; then
   LEN=${#SESSION_ID}
@@ -111,23 +164,61 @@ if [ -n "$SESSION_ID" ]; then
   fi
 fi
 
-# --- Compose. Wrapped output (if any) leads; syntaur segments trail. ---
-SYNTAUR_PARTS=""
-for seg in "$GIT_SEG" "$ASSIGNMENT_SEG" "$SESSION_SEG"; do
-  if [ -n "$seg" ]; then
-    if [ -z "$SYNTAUR_PARTS" ]; then
-      SYNTAUR_PARTS="$seg"
+# model
+MODEL_SEG=""
+[ -n "$MODEL" ] && MODEL_SEG="$MODEL"
+
+# ctx — fill bar
+CTX_SEG=""
+if [ -n "$USED_PCT" ]; then
+  USED_INT=$(printf "%.0f" "$USED_PCT" 2>/dev/null || echo "$USED_PCT")
+  if [ -n "$USED_INT" ] && [ "$USED_INT" -ge 0 ] 2>/dev/null; then
+    FILLED=$(( USED_INT / 10 ))
+    [ "$FILLED" -gt 10 ] && FILLED=10
+    EMPTY=$(( 10 - FILLED ))
+    BAR=""
+    i=0
+    while [ "$i" -lt "$FILLED" ]; do BAR="${BAR}#"; i=$((i+1)); done
+    i=0
+    while [ "$i" -lt "$EMPTY" ];  do BAR="${BAR}-"; i=$((i+1)); done
+    CTX_SEG="ctx:[${BAR}] ${USED_INT}%"
+  fi
+fi
+
+# cwd — basename
+CWD_SEG=""
+[ -n "$CWD" ] && CWD_SEG=$(basename "$CWD")
+
+# --- Emit the selected segments in order ---
+OUT=""
+# Split SEGMENTS_RAW on commas using IFS.
+OLD_IFS="$IFS"
+IFS=','
+for name in $SEGMENTS_RAW; do
+  IFS="$OLD_IFS"
+  # Trim whitespace
+  name=$(printf '%s' "$name" | awk '{$1=$1; print}')
+  value=""
+  case "$name" in
+    wrap)       value="$WRAP_SEG" ;;
+    git)        value="$GIT_SEG" ;;
+    assignment) value="$ASSIGNMENT_SEG" ;;
+    session)    value="$SESSION_SEG" ;;
+    model)      value="$MODEL_SEG" ;;
+    ctx)        value="$CTX_SEG" ;;
+    cwd)        value="$CWD_SEG" ;;
+    *)          value="" ;;
+  esac
+  if [ -n "$value" ]; then
+    if [ -z "$OUT" ]; then
+      OUT="$value"
     else
-      SYNTAUR_PARTS="$SYNTAUR_PARTS · $seg"
+      OUT="${OUT}${SEPARATOR}${value}"
     fi
   fi
+  IFS=','
 done
+IFS="$OLD_IFS"
 
-if [ -n "$WRAPPED_OUT" ] && [ -n "$SYNTAUR_PARTS" ]; then
-  printf '%s · %s' "$WRAPPED_OUT" "$SYNTAUR_PARTS"
-elif [ -n "$WRAPPED_OUT" ]; then
-  printf '%s' "$WRAPPED_OUT"
-else
-  printf '%s' "$SYNTAUR_PARTS"
-fi
+printf '%s' "$OUT"
 exit 0