cc-context-stats 1.3.0 → 1.5.1

package/scripts/context-stats.sh

@@ -57,6 +57,8 @@ COLOR_ENABLED=true
 TOKEN_DETAIL_ENABLED=true
 WATCH_MODE=true
 WATCH_INTERVAL=2
+REDUCED_MOTION=false
+CYCLE_COUNTER=0
 
 # === UTILITY FUNCTIONS ===
 
@@ -218,6 +220,144 @@ format_duration() {
     fi
 }
 
+# === ACTIVITY ICONS & WAITING TEXT ===
+
+# Waiting messages for rotating display
+WAITING_MESSAGES="Thinking... Cooking... Crunching_tokens... Compiling_plan... Running_steps... Processing... Working_on_it... Analyzing..."
+WAITING_MSG_COUNT=8
+
+get_waiting_text() {
+    local cycle=$1
+    if [ "$REDUCED_MOTION" = "true" ]; then
+        echo "Working..."
+        return
+    fi
+    # Rotate every 2 cycles
+    local msg_idx=$(( (cycle / 2) % WAITING_MSG_COUNT + 1 ))
+    local msg
+    msg=$(echo "$WAITING_MESSAGES" | awk -v n="$msg_idx" '{ print $n }')
+    # Replace underscores with spaces
+    echo "$msg" | tr '_' ' '
+}
+
+# Check if session is active (last entry within timeout seconds)
+is_session_active() {
+    local last_ts=$1
+    local timeout=${2:-30}
+    local now
+    now=$(date +%s)
+    local diff=$((now - last_ts))
+    [ "$diff" -le "$timeout" ]
+}
+
+# Detect spike: latest delta > 15% of context window OR > 3x rolling avg of previous deltas
+detect_spike() {
+    local deltas_str=$1
+    local context_window=$2
+    local window=${3:-5}
+
+    local count
+    count=$(echo "$deltas_str" | wc -w | tr -d ' ')
+    [ "$count" -eq 0 ] && return 1
+
+    local latest
+    latest=$(echo "$deltas_str" | awk '{ print $NF }')
+
+    # Absolute threshold: > 15% of context window
+    if [ "$context_window" -gt 0 ]; then
+        local threshold=$((context_window * 15 / 100))
+        [ "$latest" -gt "$threshold" ] && return 0
+    fi
+
+    # Relative threshold: > 3x rolling avg of previous deltas
+    if [ "$count" -ge 2 ]; then
+        # Get previous deltas (exclude last)
+        local prev_count=$((count - 1))
+        local start=$((prev_count > window ? count - window - 1 : 0))
+        local prev_sum=0
+        local prev_n=0
+        local idx=0
+        for d in $deltas_str; do
+            if [ "$idx" -ge "$start" ] && [ "$idx" -lt "$prev_count" ]; then
+                prev_sum=$((prev_sum + d))
+                prev_n=$((prev_n + 1))
+            fi
+            idx=$((idx + 1))
+        done
+        if [ "$prev_n" -gt 0 ]; then
+            local avg=$((prev_sum / prev_n))
+            if [ "$avg" -gt 0 ] && [ "$latest" -gt $((avg * 3)) ]; then
+                return 0
+            fi
+        fi
+    fi
+
+    return 1
+}
+
+# Determine activity tier: idle, low, medium, high, spike
+get_activity_tier() {
+    local last_ts=$1
+    local context_window=$2
+    local deltas_str=$3
+
+    # Check if idle (>30s since last entry)
+    if ! is_session_active "$last_ts"; then
+        echo "idle"
+        return
+    fi
+
+    local count
+    count=$(echo "$deltas_str" | wc -w | tr -d ' ')
+    if [ "$count" -eq 0 ]; then
+        echo "idle"
+        return
+    fi
+
+    local latest
+    latest=$(echo "$deltas_str" | awk '{ print $NF }')
+
+    if [ "$latest" -le 0 ]; then
+        echo "idle"
+        return
+    fi
+
+    # Check spike first
+    if detect_spike "$deltas_str" "$context_window"; then
+        echo "spike"
+        return
+    fi
+
+    if [ "$context_window" -le 0 ]; then
+        echo "low"
+        return
+    fi
+
+    # Delta as percentage of context window (x100 for integer math)
+    local delta_pct_x100=$((latest * 10000 / context_window))
+
+    if [ "$delta_pct_x100" -gt 500 ]; then
+        echo "high"
+    elif [ "$delta_pct_x100" -gt 200 ]; then
+        echo "medium"
+    else
+        echo "low"
+    fi
+}
+
+# Get text label for tier
+get_tier_label() {
+    local tier=$1
+    case "$tier" in
+        idle)   echo "Idle" ;;
+        low)    echo "Low activity" ;;
+        medium) echo "Active" ;;
+        high)   echo "High activity" ;;
+        spike)  echo "Spike!" ;;
+        *)      echo "Idle" ;;
+    esac
+}
+
 # === DATA FUNCTIONS ===
 
 migrate_old_state_files() {
@@ -814,6 +954,11 @@ load_config() {
                     TOKEN_DETAIL_ENABLED=false
                 fi
                 ;;
+            reduced_motion)
+                if [ "$value" = "true" ]; then
+                    REDUCED_MOTION=true
+                fi
+                ;;
             esac
         done <"$CONFIG_FILE"
     fi
@@ -841,6 +986,26 @@ render_once() {
         echo -e "${BOLD}${MAGENTA}Context Stats${RESET} ${DIM}(Session: $session_name)${RESET}"
     fi
 
+    # Activity indicator (waiting text + label)
+    local last_ts
+    last_ts=$(get_element "$TIMESTAMPS" "$DATA_COUNT")
+    local last_context
+    last_context=$(get_element "$CONTEXT_SIZES" "$DATA_COUNT")
+    [ -z "$last_context" ] && last_context=0
+
+    local tier
+    tier=$(get_activity_tier "$last_ts" "$last_context" "$DELTAS")
+    local label
+    label=$(get_tier_label "$tier")
+
+    if is_session_active "$last_ts"; then
+        local wait_text
+        wait_text=$(get_waiting_text "$CYCLE_COUNTER")
+        echo -e "  ${DIM}${wait_text} [${label}]${RESET}"
+    else
+        echo -e "  ${DIM}${label}${RESET}"
+    fi
+
     # Render graphs (use CURRENT_USED_TOKENS for actual context window usage)
     case "$GRAPH_TYPE" in
     cumulative)
@@ -893,39 +1058,42 @@ run_watch_mode() {
     printf "%s%s" "${CLEAR_SCREEN}" "${CURSOR_HOME}"
 
     while true; do
-        # Move cursor to home position (top-left) instead of clearing
-        # This prevents flickering by overwriting in place
-        printf "%s" "${CURSOR_HOME}"
-
         # Re-read terminal dimensions in case of resize
         get_terminal_dimensions
 
-        # Show watch mode indicator with live timestamp
-        local current_time
-        current_time=$(date +%H:%M:%S)
-        echo -e "${DIM}[LIVE ${current_time}] Refresh: ${WATCH_INTERVAL}s | Ctrl+C to exit${RESET}"
-
-        # Handle case where state_file is empty (no sessions found at all)
-        if [ -z "$state_file" ]; then
-            show_waiting_message "" "Waiting for session data..."
-        # Re-validate and render (file might have new data)
-        elif [ -f "$state_file" ]; then
-            local line_count
-            line_count=$(wc -l <"$state_file" | tr -d ' ')
-            if [ "$line_count" -ge 2 ]; then
-                render_once "$state_file"
+        # Capture all output into a variable for atomic write
+        local output
+        output=$(
+            # Show watch mode indicator with live timestamp
+            local current_time
+            current_time=$(date +%H:%M:%S)
+            echo -e "${DIM}[LIVE ${current_time}] Refresh: ${WATCH_INTERVAL}s | Ctrl+C to exit${RESET}"
+
+            # Handle case where state_file is empty (no sessions found at all)
+            if [ -z "$state_file" ]; then
+                local wait_msg
+                wait_msg=$(get_waiting_text "$CYCLE_COUNTER")
+                show_waiting_message "" "$wait_msg"
+            # Re-validate and render (file might have new data)
+            elif [ -f "$state_file" ]; then
+                local line_count
+                line_count=$(wc -l <"$state_file" | tr -d ' ')
+                if [ "$line_count" -ge 2 ]; then
+                    render_once "$state_file"
+                else
+                    show_waiting_message "$SESSION_ID" "Waiting for more data points..."
+                    echo -e "  ${DIM}Current: ${line_count} point(s), need at least 2${RESET}"
+                fi
             else
-                show_waiting_message "$SESSION_ID" "Waiting for more data points..."
-                echo -e "  ${DIM}Current: ${line_count} point(s), need at least 2${RESET}"
+                # File doesn't exist yet (new session)
+                show_waiting_message "$SESSION_ID" "Waiting for session data..."
             fi
-        else
-            # File doesn't exist yet (new session)
-            show_waiting_message "$SESSION_ID" "Waiting for session data..."
-        fi
+        )
 
-        # Clear any remaining lines from previous render (in case terminal resized smaller)
-        printf "%s" "${CLEAR_TO_END}"
+        # Atomic write: CURSOR_HOME + content + CLEAR_TO_END (clean up stale trailing lines)
+        printf "%s%s\n%s" "${CURSOR_HOME}" "$output" "${CLEAR_TO_END}"
 
+        CYCLE_COUNTER=$((CYCLE_COUNTER + 1))
         sleep "$WATCH_INTERVAL"
     done
 }

package/scripts/statusline-full.sh

@@ -105,9 +105,69 @@ if [[ -f ~/.claude/statusline.conf ]]; then
     if [[ "$show_session" == "false" ]]; then
         show_session_enabled=false
     fi
-    # Note: show_io_tokens setting is read but not yet implemented
 fi
 
+# Width-fitting helpers
+visible_width() {
+    # Strip ANSI escape sequences (both literal \033 and actual ESC byte) and return string length
+    local stripped
+    stripped=$(printf '%s' "$1" | sed -e $'s/\033\[[0-9;]*m//g' -e 's/\\033\[[0-9;]*m//g')
+    printf '%s' "$stripped" | wc -m | tr -d ' '
+}
+
+get_terminal_width() {
+    # Return terminal width for fit_to_width truncation.
+    # When running inside Claude Code's statusline subprocess, neither $COLUMNS
+    # nor tput can detect the real terminal width (they always return 80).
+    # If COLUMNS is explicitly set, trust it. Otherwise use 200 as default
+    # so no parts are unnecessarily dropped; Claude Code handles overflow.
+    if [[ -n "$COLUMNS" ]]; then
+        echo "$COLUMNS"
+    else
+        local cols
+        cols=$(tput cols 2>/dev/null || echo 80)
+        if [[ "$cols" -eq 80 ]]; then
+            echo 200
+        else
+            echo "$cols"
+        fi
+    fi
+}
+
+fit_to_width() {
+    # Assemble parts into a single line that fits within max_width.
+    # Usage: fit_to_width max_width part1 part2 part3 ...
+    # First part (base) is always included. Subsequent parts are
+    # included only if adding them does not exceed max_width.
+    local max_width=$1
+    shift
+    local parts=("$@")
+
+    if [[ ${#parts[@]} -eq 0 ]]; then
+        echo ""
+        return
+    fi
+
+    local result="${parts[0]}"
+    local current_width
+    current_width=$(visible_width "$result")
+
+    for ((i = 1; i < ${#parts[@]}; i++)); do
+        local part="${parts[$i]}"
+        if [[ -z "$part" ]]; then
+            continue
+        fi
+        local part_width
+        part_width=$(visible_width "$part")
+        if (( current_width + part_width <= max_width )); then
+            result+="$part"
+            (( current_width += part_width ))
+        fi
+    done
+
+    echo -e "$result"
+}
+
 # Calculate context window - show remaining free space
 context_info=""
 total_size=$(echo "$input" | jq -r '.context_window.context_window_size // 0')
@@ -212,6 +272,7 @@ if [[ "$total_size" -gt 0 && "$current_usage" != "null" ]]; then
         fi
         # Calculate delta
         delta=$((used_tokens - prev_tokens))
+        # delta calculated for display
         # Only show positive delta (and skip first run when no previous state)
         if [[ "$has_prev" == "true" && "$delta" -gt 0 ]]; then
             if [[ "$token_detail_enabled" == "true" ]]; then
@@ -238,4 +299,6 @@ if [[ "$show_session_enabled" == "true" && -n "$session_id" ]]; then
 fi
 
 # Output: [Model] directory | branch [changes] | XXk free (XX%) [+delta] [AC] [S:session_id]
-echo -e "${DIM}[${model}]${RESET} ${BLUE}${dir_name}${RESET}${git_info}${context_info}${delta_info}${ac_info}${session_info}"
+base="${DIM}[${model}]${RESET} ${BLUE}${dir_name}${RESET}"
+max_width=$(get_terminal_width)
+fit_to_width "$max_width" "$base" "$git_info" "$context_info" "$delta_info" "$ac_info" "$session_info"

package/scripts/statusline-git.sh

@@ -14,6 +14,60 @@ MODEL_DISPLAY=$(echo "$input" | jq -r '.model.display_name // "Claude"')
 CURRENT_DIR=$(echo "$input" | jq -r '.workspace.current_dir // "~"')
 DIR_NAME="${CURRENT_DIR##*/}"
 
+# Width-fitting helpers
+visible_width() {
+    local stripped
+    stripped=$(printf '%s' "$1" | sed -e $'s/\033\[[0-9;]*m//g' -e 's/\\033\[[0-9;]*m//g')
+    printf '%s' "$stripped" | wc -m | tr -d ' '
+}
+
+get_terminal_width() {
+    # When running inside Claude Code's statusline subprocess, $COLUMNS is not set
+    # and tput falls back to 80. If COLUMNS is set, trust it. Otherwise use 200
+    # so no parts are dropped; Claude Code handles overflow.
+    if [[ -n "$COLUMNS" ]]; then
+        echo "$COLUMNS"
+    else
+        local cols
+        cols=$(tput cols 2>/dev/null || echo 80)
+        if [[ "$cols" -eq 80 ]]; then
+            echo 200
+        else
+            echo "$cols"
+        fi
+    fi
+}
+
+fit_to_width() {
+    local max_width=$1
+    shift
+    local parts=("$@")
+
+    if [[ ${#parts[@]} -eq 0 ]]; then
+        echo ""
+        return
+    fi
+
+    local result="${parts[0]}"
+    local current_width
+    current_width=$(visible_width "$result")
+
+    for ((i = 1; i < ${#parts[@]}; i++)); do
+        local part="${parts[$i]}"
+        if [[ -z "$part" ]]; then
+            continue
+        fi
+        local part_width
+        part_width=$(visible_width "$part")
+        if (( current_width + part_width <= max_width )); then
+            result+="$part"
+            (( current_width += part_width ))
+        fi
+    done
+
+    echo -e "$result"
+}
+
 # Git branch detection
 GIT_INFO=""
 if git -C "$CURRENT_DIR" rev-parse --git-dir > /dev/null 2>&1; then
@@ -29,4 +83,6 @@ if git -C "$CURRENT_DIR" rev-parse --git-dir > /dev/null 2>&1; then
     fi
 fi
 
-echo -e "[${MODEL_DISPLAY}] ${BLUE}${DIR_NAME}${RESET}${GIT_INFO}"
+base="[${MODEL_DISPLAY}] ${BLUE}${DIR_NAME}${RESET}"
+max_width=$(get_terminal_width)
+fit_to_width "$max_width" "$base" "$GIT_INFO"

package/scripts/statusline-minimal.sh

@@ -8,4 +8,60 @@ MODEL_DISPLAY=$(echo "$input" | jq -r '.model.display_name // "Claude"')
 CURRENT_DIR=$(echo "$input" | jq -r '.workspace.current_dir // "~"')
 DIR_NAME="${CURRENT_DIR##*/}"
 
-echo "[$MODEL_DISPLAY] $DIR_NAME"
+# Width-fitting helpers
+visible_width() {
+    local stripped
+    stripped=$(printf '%s' "$1" | sed -e $'s/\033\[[0-9;]*m//g' -e 's/\\033\[[0-9;]*m//g')
+    printf '%s' "$stripped" | wc -m | tr -d ' '
+}
+
+get_terminal_width() {
+    # When running inside Claude Code's statusline subprocess, $COLUMNS is not set
+    # and tput falls back to 80. If COLUMNS is set, trust it. Otherwise use 200
+    # so no parts are dropped; Claude Code handles overflow.
+    if [[ -n "$COLUMNS" ]]; then
+        echo "$COLUMNS"
+    else
+        local cols
+        cols=$(tput cols 2>/dev/null || echo 80)
+        if [[ "$cols" -eq 80 ]]; then
+            echo 200
+        else
+            echo "$cols"
+        fi
+    fi
+}
+
+fit_to_width() {
+    local max_width=$1
+    shift
+    local parts=("$@")
+
+    if [[ ${#parts[@]} -eq 0 ]]; then
+        echo ""
+        return
+    fi
+
+    local result="${parts[0]}"
+    local current_width
+    current_width=$(visible_width "$result")
+
+    for ((i = 1; i < ${#parts[@]}; i++)); do
+        local part="${parts[$i]}"
+        if [[ -z "$part" ]]; then
+            continue
+        fi
+        local part_width
+        part_width=$(visible_width "$part")
+        if (( current_width + part_width <= max_width )); then
+            result+="$part"
+            (( current_width += part_width ))
+        fi
+    done
+
+    echo -e "$result"
+}
+
+base="[$MODEL_DISPLAY] $DIR_NAME"
+max_width=$(get_terminal_width)
+fit_to_width "$max_width" "$base"

package/scripts/statusline.js

@@ -42,6 +42,49 @@ const RED = '\x1b[0;31m';
 const DIM = '\x1b[2m';
 const RESET = '\x1b[0m';
 
+/**
+ * Return the visible width of a string after stripping ANSI escape sequences.
+ */
+function visibleWidth(s) {
+    // eslint-disable-next-line no-control-regex
+    return s.replace(/\x1b\[[0-9;]*m/g, '').length;
+}
+
+/**
+ * Return the terminal width in columns, defaulting to 80.
+ */
+function getTerminalWidth() {
+    return process.stdout.columns || parseInt(process.env.COLUMNS, 10) || 80;
+}
+
+/**
+ * Assemble parts into a single line that fits within maxWidth.
+ * Parts are added in priority order (first = highest priority).
+ * The first part (base) is always included.
+ */
+function fitToWidth(parts, maxWidth) {
+    if (!parts.length) {
+        return '';
+    }
+
+    let result = parts[0];
+    let currentWidth = visibleWidth(result);
+
+    for (let i = 1; i < parts.length; i++) {
+        const part = parts[i];
+        if (!part) {
+            continue;
+        }
+        const partWidth = visibleWidth(part);
+        if (currentWidth + partWidth <= maxWidth) {
+            result += part;
+            currentWidth += partWidth;
+        }
+    }
+
+    return result;
+}
+
 function getGitInfo(projectDir) {
     const gitDir = path.join(projectDir, '.git');
     if (!fs.existsSync(gitDir) || !fs.statSync(gitDir).isDirectory()) {
@@ -84,6 +127,7 @@ function readConfig() {
         showDelta: true,
         showSession: true,
         showIoTokens: true,
+        reducedMotion: false,
     };
     const configPath = path.join(os.homedir(), '.claude', 'statusline.conf');
 
@@ -134,6 +178,8 @@ show_session=true
                 config.showSession = valueTrimmed !== 'false';
             } else if (keyTrimmed === 'show_io_tokens') {
                 config.showIoTokens = valueTrimmed !== 'false';
+            } else if (keyTrimmed === 'reduced_motion') {
+                config.reducedMotion = valueTrimmed !== 'false';
             }
         }
     } catch {
@@ -343,8 +389,9 @@ process.stdin.on('end', () => {
         sessionInfo = ` ${DIM}${sessionId}${RESET}`;
     }
 
-    // Output: [Model] directory | branch [changes] | XXk free (XX%) [+delta] [AC] [S:session_id]
-    console.log(
-        `${DIM}[${model}]${RESET} ${BLUE}${dirName}${RESET}${gitInfo}${contextInfo}${deltaInfo}${acInfo}${sessionInfo}`
-    );
+    // Output: [Model] dir | branch [n] | free (%) [+delta] [AC] session
+    const base = `${DIM}[${model}]${RESET} ${BLUE}${dirName}${RESET}`;
+    const maxWidth = getTerminalWidth();
+    const parts = [base, gitInfo, contextInfo, deltaInfo, acInfo, sessionInfo];
+    console.log(fitToWidth(parts, maxWidth));
 });

package/scripts/statusline.py

@@ -26,6 +26,8 @@ State file format (CSV):
 
 import json
 import os
+import re
+import shutil
 import subprocess
 import sys
 
@@ -39,6 +41,57 @@ RED = "\033[0;31m"
 DIM = "\033[2m"
 RESET = "\033[0m"
 
+# Pattern to strip ANSI escape sequences
+_ANSI_RE = re.compile(r"\033\[[0-9;]*m")
+
+
+def visible_width(s):
+    """Return the visible width of a string after stripping ANSI escape sequences."""
+    return len(_ANSI_RE.sub("", s))
+
+
+def get_terminal_width():
+    """Return the terminal width in columns.
+
+    When running inside Claude Code's statusline subprocess, neither $COLUMNS
+    nor tput/shutil can detect the real terminal width (they always return 80).
+    If COLUMNS is not explicitly set and shutil falls back to 80, we use a
+    generous default of 200 so that no parts are unnecessarily dropped;
+    Claude Code's own UI handles any overflow/truncation.
+    """
+    # If COLUMNS is explicitly set, trust it (real terminal or test override)
+    if os.environ.get("COLUMNS"):
+        return shutil.get_terminal_size().columns
+    # No COLUMNS env var — likely a Claude Code subprocess with no real TTY.
+    # shutil will fall back to 80, which is too narrow. Use 200 instead.
+    cols = shutil.get_terminal_size(fallback=(200, 24)).columns
+    return 200 if cols == 80 else cols
+
+
+def fit_to_width(parts, max_width):
+    """Assemble parts into a single line that fits within max_width.
+
+    Parts are added in priority order (first = highest priority).
+    The first part (base) is always included. Subsequent parts are
+    included only if adding them does not exceed max_width.
+    Empty parts are skipped.
+    """
+    if not parts:
+        return ""
+
+    result = parts[0]
+    current_width = visible_width(result)
+
+    for part in parts[1:]:
+        if not part:
+            continue
+        part_width = visible_width(part)
+        if current_width + part_width <= max_width:
+            result += part
+            current_width += part_width
+
+    return result
+
 
 def get_git_info(project_dir):
     """Get git branch and change count"""
@@ -303,9 +356,10 @@ def main():
         session_info = f" {DIM}{session_id}{RESET}"
 
     # Output: [Model] directory | branch [changes] | XXk free (XX%) [+delta] [AC] [S:session_id]
-    print(
-        f"{DIM}[{model}]{RESET} {BLUE}{dir_name}{RESET}{git_info}{context_info}{delta_info}{ac_info}{session_info}"
-    )
+    base = f"{DIM}[{model}]{RESET} {BLUE}{dir_name}{RESET}"
+    max_width = get_terminal_width()
+    parts = [base, git_info, context_info, delta_info, ac_info, session_info]
+    print(fit_to_width(parts, max_width))
 
 
 if __name__ == "__main__":

package/src/claude_statusline/__init__.py

@@ -3,7 +3,7 @@
 Never run out of context unexpectedly - monitor your session context in real-time.
 """
 
-__version__ = "1.2.3"
+__version__ = "1.5.1"
 
 from claude_statusline.core.config import Config
 from claude_statusline.core.state import StateFile