cc-context-stats 1.6.1 → 1.7.0

package/tests/bash/test_delta_parity.bats

@@ -0,0 +1,199 @@
+#!/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/python/test_colors.py

@@ -0,0 +1,105 @@
+"""Tests for configurable colors."""
+
+from claude_statusline.core.colors import (
+    BLUE,
+    CYAN,
+    GREEN,
+    MAGENTA,
+    RED,
+    YELLOW,
+    ColorManager,
+    parse_color,
+)
+
+
+class TestParseColor:
+    """Tests for parse_color()."""
+
+    def test_named_color_red(self):
+        assert parse_color("red") == "\033[0;31m"
+
+    def test_named_color_green(self):
+        assert parse_color("green") == "\033[0;32m"
+
+    def test_named_color_bright_cyan(self):
+        assert parse_color("bright_cyan") == "\033[0;96m"
+
+    def test_named_color_case_insensitive(self):
+        assert parse_color("RED") == "\033[0;31m"
+        assert parse_color("Green") == "\033[0;32m"
+
+    def test_hex_color(self):
+        result = parse_color("#ff5733")
+        assert result == "\033[38;2;255;87;51m"
+
+    def test_hex_color_uppercase(self):
+        result = parse_color("#FF5733")
+        assert result == "\033[38;2;255;87;51m"
+
+    def test_hex_color_black(self):
+        result = parse_color("#000000")
+        assert result == "\033[38;2;0;0;0m"
+
+    def test_hex_color_white(self):
+        result = parse_color("#ffffff")
+        assert result == "\033[38;2;255;255;255m"
+
+    def test_invalid_color_returns_none(self):
+        assert parse_color("nonexistent") is None
+
+    def test_empty_string_returns_none(self):
+        assert parse_color("") is None
+
+    def test_invalid_hex_returns_none(self):
+        assert parse_color("#xyz") is None
+        assert parse_color("#12345") is None
+        assert parse_color("#1234567") is None
+
+    def test_strips_whitespace(self):
+        assert parse_color("  red  ") == "\033[0;31m"
+        assert parse_color("  #ff5733  ") == "\033[38;2;255;87;51m"
+
+
+class TestColorManager:
+    """Tests for ColorManager with overrides."""
+
+    def test_defaults_without_overrides(self):
+        cm = ColorManager(enabled=True)
+        assert cm.green == GREEN
+        assert cm.yellow == YELLOW
+        assert cm.red == RED
+        assert cm.blue == BLUE
+        assert cm.magenta == MAGENTA
+        assert cm.cyan == CYAN
+
+    def test_override_single_color(self):
+        custom = "\033[38;2;255;0;0m"
+        cm = ColorManager(enabled=True, overrides={"green": custom})
+        assert cm.green == custom
+        # Others unchanged
+        assert cm.yellow == YELLOW
+        assert cm.red == RED
+
+    def test_override_multiple_colors(self):
+        overrides = {
+            "green": "\033[38;2;0;255;0m",
+            "red": "\033[38;2;255;0;0m",
+        }
+        cm = ColorManager(enabled=True, overrides=overrides)
+        assert cm.green == overrides["green"]
+        assert cm.red == overrides["red"]
+        assert cm.yellow == YELLOW  # not overridden
+
+    def test_disabled_returns_empty(self):
+        overrides = {"green": "\033[38;2;0;255;0m"}
+        cm = ColorManager(enabled=False, overrides=overrides)
+        assert cm.green == ""
+        assert cm.yellow == ""
+        assert cm.bold == ""
+        assert cm.reset == ""
+
+    def test_bold_dim_reset_not_overridable(self):
+        """bold, dim, reset are always the standard ANSI codes."""
+        cm = ColorManager(enabled=True, overrides={"bold": "custom"})
+        # bold is not in the _get path, it uses the hardcoded value
+        assert cm.bold == "\033[1m"

package/tests/python/test_config_colors.py

@@ -0,0 +1,78 @@
+"""Tests for color configuration in Config."""
+
+from claude_statusline.core.config import Config
+
+
+class TestConfigColorOverrides:
+    """Tests for loading color overrides from config file."""
+
+    def test_no_color_overrides_by_default(self, tmp_path):
+        config_file = tmp_path / "statusline.conf"
+        config_file.write_text("autocompact=true\n")
+        config = Config.load(config_path=config_file)
+        assert config.color_overrides == {}
+
+    def test_named_color_override(self, tmp_path):
+        config_file = tmp_path / "statusline.conf"
+        config_file.write_text("color_green=bright_cyan\n")
+        config = Config.load(config_path=config_file)
+        assert "green" in config.color_overrides
+        assert config.color_overrides["green"] == "\033[0;96m"
+
+    def test_hex_color_override(self, tmp_path):
+        config_file = tmp_path / "statusline.conf"
+        config_file.write_text("color_red=#f7768e\n")
+        config = Config.load(config_path=config_file)
+        assert "red" in config.color_overrides
+        assert config.color_overrides["red"] == "\033[38;2;247;118;142m"
+
+    def test_multiple_color_overrides(self, tmp_path):
+        config_file = tmp_path / "statusline.conf"
+        config_file.write_text("color_green=#7dcfff\ncolor_red=#f7768e\ncolor_blue=bright_blue\n")
+        config = Config.load(config_path=config_file)
+        assert len(config.color_overrides) == 3
+        assert "green" in config.color_overrides
+        assert "red" in config.color_overrides
+        assert "blue" in config.color_overrides
+
+    def test_invalid_color_ignored(self, tmp_path, capsys):
+        config_file = tmp_path / "statusline.conf"
+        config_file.write_text("color_green=nonexistent_color\n")
+        config = Config.load(config_path=config_file)
+        assert config.color_overrides == {}
+
+    def test_color_overrides_mixed_with_booleans(self, tmp_path):
+        config_file = tmp_path / "statusline.conf"
+        config_file.write_text("autocompact=false\ntoken_detail=true\ncolor_yellow=#e0af68\n")
+        config = Config.load(config_path=config_file)
+        assert config.autocompact is False
+        assert config.token_detail is True
+        assert "yellow" in config.color_overrides
+        assert config.color_overrides["yellow"] == "\033[38;2;224;175;104m"
+
+    def test_color_overrides_in_to_dict(self, tmp_path):
+        config_file = tmp_path / "statusline.conf"
+        config_file.write_text("color_cyan=#00ffff\n")
+        config = Config.load(config_path=config_file)
+        d = config.to_dict()
+        assert "color_overrides" in d
+        assert "cyan" in d["color_overrides"]
+
+    def test_unknown_color_key_ignored(self, tmp_path):
+        config_file = tmp_path / "statusline.conf"
+        config_file.write_text("color_purple=magenta\n")
+        config = Config.load(config_path=config_file)
+        assert config.color_overrides == {}
+
+    def test_all_six_color_slots(self, tmp_path):
+        config_file = tmp_path / "statusline.conf"
+        config_file.write_text(
+            "color_green=green\n"
+            "color_yellow=yellow\n"
+            "color_red=red\n"
+            "color_blue=blue\n"
+            "color_magenta=magenta\n"
+            "color_cyan=cyan\n"
+        )
+        config = Config.load(config_path=config_file)
+        assert len(config.color_overrides) == 6

package/tests/python/test_explain.py

@@ -0,0 +1,177 @@
+"""Tests for the context-stats explain command."""
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).parent.parent.parent
+FIXTURES_DIR = PROJECT_ROOT / "tests" / "fixtures" / "json"
+
+
+class TestExplainCommand:
+    """Tests for `context-stats explain`."""
+
+    def _run_explain(self, input_data, extra_args=None):
+        """Run context-stats explain with JSON input and return stdout."""
+        cmd = [sys.executable, "-m", "claude_statusline.cli.context_stats", "explain"]
+        if extra_args:
+            cmd.extend(extra_args)
+        result = subprocess.run(
+            cmd,
+            input=json.dumps(input_data),
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        return result
+
+    def test_explain_shows_model(self):
+        data = {"model": {"display_name": "Opus 4.5", "id": "claude-opus-4-5"}}
+        result = self._run_explain(data)
+        assert result.returncode == 0
+        assert "Opus 4.5" in result.stdout
+        assert "claude-opus-4-5" in result.stdout
+
+    def test_explain_shows_workspace(self):
+        data = {
+            "workspace": {
+                "current_dir": "/home/user/project",
+                "project_dir": "/home/user/project",
+            }
+        }
+        result = self._run_explain(data)
+        assert result.returncode == 0
+        assert "/home/user/project" in result.stdout
+
+    def test_explain_shows_context_window(self):
+        data = {
+            "context_window": {
+                "context_window_size": 200000,
+                "current_usage": {
+                    "input_tokens": 50000,
+                    "cache_creation_input_tokens": 10000,
+                    "cache_read_input_tokens": 20000,
+                },
+            }
+        }
+        result = self._run_explain(data)
+        assert result.returncode == 0
+        assert "200,000" in result.stdout
+        assert "50,000" in result.stdout
+        assert "context_used" in result.stdout
+
+    def test_explain_shows_cost(self):
+        data = {
+            "cost": {
+                "total_cost_usd": 0.1234,
+                "total_lines_added": 100,
+                "total_lines_removed": 50,
+            }
+        }
+        result = self._run_explain(data)
+        assert result.returncode == 0
+        assert "$0.1234" in result.stdout
+
+    def test_explain_shows_session(self):
+        data = {"session_id": "abc-123", "version": "2.0.0"}
+        result = self._run_explain(data)
+        assert result.returncode == 0
+        assert "abc-123" in result.stdout
+        assert "2.0.0" in result.stdout
+
+    def test_explain_shows_absent_fields(self):
+        data = {}
+        result = self._run_explain(data)
+        assert result.returncode == 0
+        assert "(absent)" in result.stdout
+
+    def test_explain_shows_raw_json(self):
+        data = {"model": {"display_name": "Test"}}
+        result = self._run_explain(data)
+        assert result.returncode == 0
+        assert "Raw JSON" in result.stdout
+        assert '"display_name": "Test"' in result.stdout
+
+    def test_explain_shows_config(self):
+        data = {}
+        result = self._run_explain(data)
+        assert result.returncode == 0
+        assert "Active Config" in result.stdout
+
+    def test_explain_with_full_fixture(self):
+        with open(FIXTURES_DIR / "valid_full.json") as f:
+            data = json.load(f)
+        result = self._run_explain(data)
+        assert result.returncode == 0
+        assert "Opus 4.5" in result.stdout
+        assert "test-session-123" in result.stdout
+
+    def test_explain_invalid_json_fails(self):
+        result = subprocess.run(
+            [sys.executable, "-m", "claude_statusline.cli.context_stats", "explain"],
+            input="not valid json",
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        assert result.returncode == 1
+        assert "invalid JSON" in result.stderr
+
+    def test_explain_shows_derived_free_tokens(self):
+        data = {
+            "context_window": {
+                "context_window_size": 200000,
+                "current_usage": {
+                    "input_tokens": 50000,
+                    "cache_creation_input_tokens": 10000,
+                    "cache_read_input_tokens": 20000,
+                },
+            }
+        }
+        result = self._run_explain(data)
+        assert result.returncode == 0
+        # 200000 - (50000+10000+20000) = 120000
+        assert "120,000" in result.stdout
+        assert "60.0%" in result.stdout
+
+    def test_explain_no_color_flag(self):
+        data = {"model": {"display_name": "Test"}}
+        result = subprocess.run(
+            [sys.executable, "-m", "claude_statusline.cli.context_stats", "explain", "--no-color"],
+            input=json.dumps(data),
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        assert result.returncode == 0
+        assert "Test" in result.stdout
+        # No ANSI escape codes when --no-color is passed
+        assert "\x1b[" not in result.stdout
+
+    def test_explain_shows_vim_mode(self):
+        data = {"vim": {"mode": "NORMAL"}}
+        result = self._run_explain(data)
+        assert result.returncode == 0
+        assert "NORMAL" in result.stdout
+        assert "Extensions" in result.stdout
+
+    def test_explain_shows_agent(self):
+        data = {"agent": {"name": "my-agent"}}
+        result = self._run_explain(data)
+        assert result.returncode == 0
+        assert "my-agent" in result.stdout
+        assert "Extensions" in result.stdout
+
+    def test_explain_shows_output_style(self):
+        data = {"output_style": {"name": "concise"}}
+        result = self._run_explain(data)
+        assert result.returncode == 0
+        assert "concise" in result.stdout
+        assert "Extensions" in result.stdout
+
+    def test_explain_no_extensions_section_when_absent(self):
+        data = {"model": {"display_name": "Test"}}
+        result = self._run_explain(data)
+        assert result.returncode == 0
+        assert "Extensions" not in result.stdout