cc-context-stats 1.8.0 → 1.8.2

package/src/claude_statusline/graphs/statistics.py

@@ -1,92 +0,0 @@
-"""Statistical calculations for token data."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-
-@dataclass
-class Stats:
-    """Statistical summary of a data series."""
-
-    min_val: int
-    max_val: int
-    avg_val: int
-    total: int
-    count: int
-
-
-def calculate_stats(data: list[int]) -> Stats:
-    """Calculate basic statistics for a list of integers.
-
-    Args:
-        data: List of integer values
-
-    Returns:
-        Stats object with min, max, avg, total, and count
-    """
-    if not data:
-        return Stats(min_val=0, max_val=0, avg_val=0, total=0, count=0)
-
-    min_val = min(data)
-    max_val = max(data)
-    total = sum(data)
-    count = len(data)
-    avg_val = total // count if count > 0 else 0
-
-    return Stats(min_val=min_val, max_val=max_val, avg_val=avg_val, total=total, count=count)
-
-
-def detect_spike(deltas: list[int], context_window_size: int, window: int = 5) -> bool:
-    """Check if the latest delta is a spike.
-
-    A spike is defined as:
-    - Latest delta > 15% of context window size, OR
-    - Latest delta > 3x the rolling average of the last `window` deltas
-
-    Args:
-        deltas: List of token deltas
-        context_window_size: Total context window size in tokens
-        window: Number of recent deltas for rolling average (default: 5)
-
-    Returns:
-        True if the latest delta qualifies as a spike
-    """
-    if not deltas:
-        return False
-
-    latest = deltas[-1]
-
-    # Check absolute threshold: > 15% of context window
-    if context_window_size > 0 and latest > context_window_size * 0.15:
-        return True
-
-    # Check relative threshold: > 3x rolling average of previous deltas
-    previous = deltas[-(window + 1):-1] if len(deltas) > window else deltas[:-1]
-    if previous:
-        avg = sum(previous) / len(previous)
-        if avg > 0 and latest > avg * 3:
-            return True
-
-    return False
-
-
-def calculate_deltas(values: list[int]) -> list[int]:
-    """Calculate deltas between consecutive values.
-
-    Args:
-        values: List of values (e.g., cumulative token counts)
-
-    Returns:
-        List of deltas (length = len(values) - 1)
-    """
-    if len(values) < 2:
-        return []
-
-    deltas = []
-    for i in range(1, len(values)):
-        delta = values[i] - values[i - 1]
-        # Handle negative deltas (session reset) by showing 0
-        deltas.append(max(0, delta))
-
-    return deltas

package/src/claude_statusline/ui/__init__.py

@@ -1 +0,0 @@
-"""UI components for context-stats display."""

package/src/claude_statusline/ui/icons.py

@@ -1,93 +0,0 @@
-"""Activity tier detection for token usage visualization."""
-
-from __future__ import annotations
-
-from enum import Enum
-
-from claude_statusline.core.state import StateEntry
-from claude_statusline.graphs.statistics import calculate_deltas, detect_spike
-
-
-class ActivityTier(Enum):
-    """Token activity intensity tiers."""
-
-    IDLE = "idle"
-    LOW = "low"
-    MEDIUM = "medium"
-    HIGH = "high"
-    SPIKE = "spike"
-
-
-# Tier labels for accessibility (understandable without color)
-TIER_LABELS: dict[ActivityTier, str] = {
-    ActivityTier.IDLE: "Idle",
-    ActivityTier.LOW: "Low activity",
-    ActivityTier.MEDIUM: "Active",
-    ActivityTier.HIGH: "High activity",
-    ActivityTier.SPIKE: "Spike!",
-}
-
-
-def get_activity_tier(
-    entries: list[StateEntry],
-    context_window_size: int,
-) -> ActivityTier:
-    """Determine the current activity tier based on recent token deltas.
-
-    Args:
-        entries: List of StateEntry objects (chronological order)
-        context_window_size: Total context window size in tokens
-
-    Returns:
-        The current ActivityTier
-    """
-    if len(entries) < 2:
-        return ActivityTier.IDLE
-
-    # Check if session is idle (>30s since last entry)
-    import time
-
-    now = int(time.time())
-    last_timestamp = entries[-1].timestamp
-    if now - last_timestamp > 30:
-        return ActivityTier.IDLE
-
-    # Calculate deltas from context usage
-    context_used = [e.current_used_tokens for e in entries]
-    deltas = calculate_deltas(context_used)
-
-    if not deltas:
-        return ActivityTier.IDLE
-
-    latest_delta = deltas[-1]
-
-    if context_window_size <= 0:
-        return ActivityTier.LOW if latest_delta > 0 else ActivityTier.IDLE
-
-    # Check for spike first (highest priority)
-    if detect_spike(deltas, context_window_size):
-        return ActivityTier.SPIKE
-
-    # Calculate delta as percentage of context window
-    delta_pct = (latest_delta / context_window_size) * 100
-
-    if delta_pct > 5:
-        return ActivityTier.HIGH
-    elif delta_pct > 2:
-        return ActivityTier.MEDIUM
-    elif latest_delta > 0:
-        return ActivityTier.LOW
-    else:
-        return ActivityTier.IDLE
-
-
-def get_tier_label(tier: ActivityTier) -> str:
-    """Get an accessible text label for a tier.
-
-    Args:
-        tier: The activity tier
-
-    Returns:
-        Human-readable label string
-    """
-    return TIER_LABELS.get(tier, "")

package/src/claude_statusline/ui/waiting.py

@@ -1,62 +0,0 @@
-"""Rotating waiting text for active sessions."""
-
-from __future__ import annotations
-
-import time
-
-from claude_statusline.core.state import StateEntry
-
-WAITING_MESSAGES = [
-    "Thinking...",
-    "Cooking...",
-    "Crunching tokens...",
-    "Compiling plan...",
-    "Running steps...",
-    "Processing...",
-    "Working on it...",
-    "Analyzing...",
-]
-
-# Static message for reduced-motion mode
-STATIC_MESSAGE = "Working..."
-
-
-def get_waiting_text(cycle_index: int, reduced_motion: bool = False) -> str:
-    """Get the current waiting text based on the refresh cycle.
-
-    Messages rotate every 2 cycles (approximately every 4 seconds at 2s refresh).
-
-    Args:
-        cycle_index: The current watch-mode refresh counter
-        reduced_motion: If True, return a static message instead of rotating
-
-    Returns:
-        A waiting message string
-    """
-    if reduced_motion:
-        return STATIC_MESSAGE
-
-    # Rotate every 2 cycles to keep it readable
-    message_index = (cycle_index // 2) % len(WAITING_MESSAGES)
-    return WAITING_MESSAGES[message_index]
-
-
-def is_active(entries: list[StateEntry], timeout: int = 30) -> bool:
-    """Determine if the session is currently active.
-
-    A session is considered active if the most recent state entry
-    was recorded within `timeout` seconds of the current time.
-
-    Args:
-        entries: List of StateEntry objects (chronological order)
-        timeout: Seconds since last entry to consider session active (default: 30)
-
-    Returns:
-        True if the session appears to be actively running
-    """
-    if not entries:
-        return False
-
-    now = int(time.time())
-    last_timestamp = entries[-1].timestamp
-    return (now - last_timestamp) <= timeout

package/tests/bash/test_delta_parity.bats

@@ -1,199 +0,0 @@
-#!/usr/bin/env bats
-
-# Delta calculation parity tests: Python vs Node.js statusline scripts
-# Verifies both implementations compute identical deltas from identical state.
-
-strip_ansi() {
-    printf '%s' "$1" | sed -e $'s/\033\[[0-9;]*m//g' -e 's/\\033\[[0-9;]*m//g'
-}
-
-setup() {
-    PROJECT_ROOT="$(cd "$BATS_TEST_DIRNAME/../.." && pwd)"
-    PYTHON_SCRIPT="$PROJECT_ROOT/scripts/statusline.py"
-    NODE_SCRIPT="$PROJECT_ROOT/scripts/statusline.js"
-
-    # Create isolated temp HOME so state files don't pollute real ~/.claude/
-    TEST_HOME=$(mktemp -d)
-    export HOME="$TEST_HOME"
-
-    # Normalize terminal width for deterministic output
-    export COLUMNS=200
-
-    # Enable delta display
-    mkdir -p "$TEST_HOME/.claude"
-    echo "show_delta=true" > "$TEST_HOME/.claude/statusline.conf"
-
-    # Create a non-git temp working directory so both scripts skip git info
-    TEST_WORKDIR=$(mktemp -d)
-    cd "$TEST_WORKDIR"
-}
-
-teardown() {
-    rm -rf "$TEST_HOME"
-    rm -rf "$TEST_WORKDIR"
-}
-
-# Helper: create a JSON payload with specific token values and session_id
-make_payload() {
-    local session="$1" input_tokens="$2" cache_creation="$3" cache_read="$4"
-    cat <<EOF
-{
-  "model": {"display_name": "Opus 4.5"},
-  "workspace": {"current_dir": "$TEST_WORKDIR", "project_dir": "$TEST_WORKDIR"},
-  "session_id": "$session",
-  "context_window": {
-    "context_window_size": 200000,
-    "current_usage": {
-      "input_tokens": $input_tokens,
-      "cache_creation_input_tokens": $cache_creation,
-      "cache_read_input_tokens": $cache_read
-    }
-  }
-}
-EOF
-}
-
-# ============================================
-# Delta Calculation Parity Tests
-# ============================================
-
-@test "delta parity: both scripts show identical delta after two sequential payloads" {
-    # First payload: 30k context usage (10k input + 10k cache_create + 10k cache_read)
-    local py_session="delta-parity-py"
-    local node_session="delta-parity-node"
-
-    local payload1_py=$(make_payload "$py_session" 10000 10000 10000)
-    local payload1_node=$(make_payload "$node_session" 10000 10000 10000)
-
-    # Run first payload (seeds state file, no delta shown)
-    echo "$payload1_py" | python3 "$PYTHON_SCRIPT" > /dev/null 2>&1
-    echo "$payload1_node" | node "$NODE_SCRIPT" > /dev/null 2>&1
-
-    # Second payload: 80k context usage (40k input + 20k cache_create + 20k cache_read)
-    # Expected delta = 80k - 30k = 50k
-    local payload2_py=$(make_payload "$py_session" 40000 20000 20000)
-    local payload2_node=$(make_payload "$node_session" 40000 20000 20000)
-
-    local py_output=$(echo "$payload2_py" | python3 "$PYTHON_SCRIPT" 2>/dev/null)
-    local node_output=$(echo "$payload2_node" | node "$NODE_SCRIPT" 2>/dev/null)
-
-    local py_clean=$(strip_ansi "$py_output")
-    local node_clean=$(strip_ansi "$node_output")
-
-    # Both should contain [+50,000] delta
-    if [[ "$py_clean" != *"[+50,000]"* ]]; then
-        echo "Python output missing expected delta [+50,000]"
-        echo "Python output: $py_clean"
-        return 1
-    fi
-    if [[ "$node_clean" != *"[+50,000]"* ]]; then
-        echo "Node.js output missing expected delta [+50,000]"
-        echo "Node.js output: $node_clean"
-        return 1
-    fi
-
-    # Compare outputs ignoring session_id suffix (which intentionally differs)
-    # Strip the trailing session ID from both outputs for comparison
-    local py_no_session=$(echo "$py_clean" | sed 's/ delta-parity-py$//')
-    local node_no_session=$(echo "$node_clean" | sed 's/ delta-parity-node$//')
-
-    if [ "$py_no_session" != "$node_no_session" ]; then
-        echo "DELTA PARITY MISMATCH (ignoring session_id)"
-        echo "Python:  $py_no_session"
-        echo "Node.js: $node_no_session"
-        return 1
-    fi
-}
-
-@test "delta parity: no delta shown on first run (no previous state)" {
-    local py_session="delta-first-py"
-    local node_session="delta-first-node"
-
-    local payload_py=$(make_payload "$py_session" 50000 10000 5000)
-    local payload_node=$(make_payload "$node_session" 50000 10000 5000)
-
-    local py_output=$(echo "$payload_py" | python3 "$PYTHON_SCRIPT" 2>/dev/null)
-    local node_output=$(echo "$payload_node" | node "$NODE_SCRIPT" 2>/dev/null)
-
-    local py_clean=$(strip_ansi "$py_output")
-    local node_clean=$(strip_ansi "$node_output")
-
-    # Neither should show a delta on first run
-    if [[ "$py_clean" == *"[+"* ]]; then
-        echo "Python should not show delta on first run"
-        echo "Python output: $py_clean"
-        return 1
-    fi
-    if [[ "$node_clean" == *"[+"* ]]; then
-        echo "Node.js should not show delta on first run"
-        echo "Node.js output: $node_clean"
-        return 1
-    fi
-}
-
-@test "delta parity: no delta shown when tokens decrease (context reset)" {
-    local py_session="delta-decrease-py"
-    local node_session="delta-decrease-node"
-
-    # First payload: high usage
-    local payload1_py=$(make_payload "$py_session" 80000 20000 10000)
-    local payload1_node=$(make_payload "$node_session" 80000 20000 10000)
-
-    echo "$payload1_py" | python3 "$PYTHON_SCRIPT" > /dev/null 2>&1
-    echo "$payload1_node" | node "$NODE_SCRIPT" > /dev/null 2>&1
-
-    # Second payload: lower usage (context was reset/compacted)
-    local payload2_py=$(make_payload "$py_session" 20000 5000 5000)
-    local payload2_node=$(make_payload "$node_session" 20000 5000 5000)
-
-    local py_output=$(echo "$payload2_py" | python3 "$PYTHON_SCRIPT" 2>/dev/null)
-    local node_output=$(echo "$payload2_node" | node "$NODE_SCRIPT" 2>/dev/null)
-
-    local py_clean=$(strip_ansi "$py_output")
-    local node_clean=$(strip_ansi "$node_output")
-
-    # Neither should show delta when tokens decrease
-    if [[ "$py_clean" == *"[+"* ]]; then
-        echo "Python should not show delta when tokens decrease"
-        echo "Python output: $py_clean"
-        return 1
-    fi
-    if [[ "$node_clean" == *"[+"* ]]; then
-        echo "Node.js should not show delta when tokens decrease"
-        echo "Node.js output: $node_clean"
-        return 1
-    fi
-}
-
-@test "delta parity: duplicate guard prevents writing when tokens unchanged" {
-    local py_session="delta-dedup-py"
-    local node_session="delta-dedup-node"
-
-    local payload_py=$(make_payload "$py_session" 50000 10000 5000)
-    local payload_node=$(make_payload "$node_session" 50000 10000 5000)
-
-    # Run same payload three times
-    echo "$payload_py" | python3 "$PYTHON_SCRIPT" > /dev/null 2>&1
-    echo "$payload_py" | python3 "$PYTHON_SCRIPT" > /dev/null 2>&1
-    echo "$payload_py" | python3 "$PYTHON_SCRIPT" > /dev/null 2>&1
-
-    echo "$payload_node" | node "$NODE_SCRIPT" > /dev/null 2>&1
-    echo "$payload_node" | node "$NODE_SCRIPT" > /dev/null 2>&1
-    echo "$payload_node" | node "$NODE_SCRIPT" > /dev/null 2>&1
-
-    local py_state="$TEST_HOME/.claude/statusline/statusline.${py_session}.state"
-    local node_state="$TEST_HOME/.claude/statusline/statusline.${node_session}.state"
-
-    # Both should have written only 1 line (duplicate guard)
-    local py_lines=$(wc -l < "$py_state" | tr -d ' ')
-    local node_lines=$(wc -l < "$node_state" | tr -d ' ')
-
-    if [ "$py_lines" -ne 1 ]; then
-        echo "Python wrote $py_lines lines (expected 1 — duplicate guard failed)"
-        return 1
-    fi
-    if [ "$node_lines" -ne 1 ]; then
-        echo "Node.js wrote $node_lines lines (expected 1 — duplicate guard failed)"
-        return 1
-    fi
-}

package/tests/bash/test_install.bats

@@ -1,29 +0,0 @@
-#!/usr/bin/env bats
-
-# Test suite for install.sh
-
-setup() {
-    PROJECT_ROOT="$(cd "$BATS_TEST_DIRNAME/../.." && pwd)"
-    SCRIPT="$PROJECT_ROOT/install.sh"
-}
-
-@test "install.sh exists and is executable" {
-    [ -f "$SCRIPT" ]
-    [ -x "$SCRIPT" ]
-}
-
-@test "install.sh contains expected functions" {
-    grep -q "check_jq" "$SCRIPT"
-    grep -q "select_script" "$SCRIPT"
-    grep -q "ensure_claude_dir" "$SCRIPT"
-    grep -q "install_script" "$SCRIPT"
-    grep -q "update_settings" "$SCRIPT"
-}
-
-@test "install.sh has correct shebang" {
-    head -1 "$SCRIPT" | grep -q "#!/bin/bash"
-}
-
-@test "install.sh uses set -e for error handling" {
-    grep -q "set -e" "$SCRIPT"
-}