cc-context-stats 1.8.0 → 1.8.2

package/tests/python/test_explain.py

@@ -1,177 +0,0 @@
-"""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

package/tests/python/test_icons.py

@@ -1,152 +0,0 @@
-"""Tests for activity tier detection."""
-
-import time
-
-from claude_statusline.core.state import StateEntry
-from claude_statusline.graphs.statistics import detect_spike
-from claude_statusline.ui.icons import (
-    ActivityTier,
-    get_activity_tier,
-    get_tier_label,
-)
-
-
-def _make_entry(
-    timestamp: int = 0,
-    current_input: int = 1000,
-    cache_creation: int = 0,
-    cache_read: int = 0,
-    context_window_size: int = 200_000,
-) -> StateEntry:
-    """Helper to create a StateEntry for testing."""
-    return StateEntry(
-        timestamp=timestamp,
-        total_input_tokens=current_input,
-        total_output_tokens=0,
-        current_input_tokens=current_input,
-        current_output_tokens=0,
-        cache_creation=cache_creation,
-        cache_read=cache_read,
-        cost_usd=0.0,
-        lines_added=0,
-        lines_removed=0,
-        session_id="test",
-        model_id="test-model",
-        workspace_project_dir="/tmp/test",
-        context_window_size=context_window_size,
-    )
-
-
-class TestDetectSpike:
-    """Tests for spike detection logic."""
-
-    def test_empty_deltas(self):
-        assert detect_spike([], 200_000) is False
-
-    def test_no_spike_small_delta(self):
-        deltas = [1000, 1200, 1100, 900, 1000]
-        assert detect_spike(deltas, 200_000) is False
-
-    def test_spike_absolute_threshold(self):
-        """Delta > 15% of context window is a spike."""
-        deltas = [1000, 1200, 1100, 900, 35_000]
-        assert detect_spike(deltas, 200_000) is True
-
-    def test_spike_relative_threshold(self):
-        """Delta > 3x rolling average is a spike."""
-        deltas = [100, 100, 100, 100, 500]
-        assert detect_spike(deltas, 200_000) is True
-
-    def test_no_spike_when_all_similar(self):
-        deltas = [1000, 1000, 1000, 1000, 1000]
-        assert detect_spike(deltas, 200_000) is False
-
-    def test_single_delta_no_spike(self):
-        """Single delta can't be a relative spike (no average to compare)."""
-        deltas = [1000]
-        assert detect_spike(deltas, 200_000) is False
-
-    def test_spike_with_zero_context_window(self):
-        """Only relative threshold applies when context_window is 0."""
-        deltas = [100, 100, 100, 100, 500]
-        assert detect_spike(deltas, 0) is True
-
-
-class TestActivityTier:
-    """Tests for activity tier determination."""
-
-    def test_idle_with_no_entries(self):
-        assert get_activity_tier([], 200_000) == ActivityTier.IDLE
-
-    def test_idle_with_single_entry(self):
-        entry = _make_entry(timestamp=int(time.time()))
-        assert get_activity_tier([entry], 200_000) == ActivityTier.IDLE
-
-    def test_idle_when_stale(self):
-        """Entries older than 30s should be idle."""
-        old_time = int(time.time()) - 60
-        entries = [
-            _make_entry(timestamp=old_time, current_input=1000),
-            _make_entry(timestamp=old_time + 5, current_input=2000),
-        ]
-        assert get_activity_tier(entries, 200_000) == ActivityTier.IDLE
-
-    def test_low_activity(self):
-        """Small delta (<2% of window) = low."""
-        now = int(time.time())
-        entries = [
-            _make_entry(timestamp=now - 5, current_input=1000),
-            _make_entry(timestamp=now, current_input=2000),  # delta=1000, 0.5% of 200k
-        ]
-        assert get_activity_tier(entries, 200_000) == ActivityTier.LOW
-
-    def test_medium_activity(self):
-        """Delta 2-5% of window = medium."""
-        now = int(time.time())
-        entries = [
-            _make_entry(timestamp=now - 5, current_input=1000),
-            _make_entry(timestamp=now, current_input=7000),  # delta=6000, 3% of 200k
-        ]
-        assert get_activity_tier(entries, 200_000) == ActivityTier.MEDIUM
-
-    def test_high_activity(self):
-        """Delta 5-15% of window = high."""
-        now = int(time.time())
-        entries = [
-            _make_entry(timestamp=now - 5, current_input=1000),
-            _make_entry(timestamp=now, current_input=21000),  # delta=20000, 10% of 200k
-        ]
-        assert get_activity_tier(entries, 200_000) == ActivityTier.HIGH
-
-    def test_spike_activity(self):
-        """Delta > 15% of window = spike."""
-        now = int(time.time())
-        entries = [
-            _make_entry(timestamp=now - 5, current_input=1000),
-            _make_entry(timestamp=now, current_input=41000),  # delta=40000, 20% of 200k
-        ]
-        assert get_activity_tier(entries, 200_000) == ActivityTier.SPIKE
-
-    def test_zero_delta_is_idle(self):
-        """No token change = idle (even if recent)."""
-        now = int(time.time())
-        entries = [
-            _make_entry(timestamp=now - 5, current_input=1000),
-            _make_entry(timestamp=now, current_input=1000),  # delta=0
-        ]
-        assert get_activity_tier(entries, 200_000) == ActivityTier.IDLE
-
-
-class TestGetTierLabel:
-    """Tests for tier labels."""
-
-    def test_all_tiers_have_labels(self):
-        for tier in ActivityTier:
-            label = get_tier_label(tier)
-            assert len(label) > 0
-
-    def test_idle_label(self):
-        assert get_tier_label(ActivityTier.IDLE) == "Idle"
-
-    def test_spike_label(self):
-        assert get_tier_label(ActivityTier.SPIKE) == "Spike!"

package/tests/python/test_intelligence.py

@@ -1,314 +0,0 @@
-"""Tests for Model Intelligence (MI) score computation."""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-import pytest
-
-from claude_statusline.core.state import StateEntry
-from claude_statusline.graphs.intelligence import (
-    MI_GREEN_THRESHOLD,
-    MI_WEIGHT_CPS,
-    MI_WEIGHT_ES,
-    MI_WEIGHT_PS,
-    MI_YELLOW_THRESHOLD,
-    IntelligenceScore,
-    calculate_context_pressure,
-    calculate_efficiency,
-    calculate_intelligence,
-    calculate_productivity,
-    format_mi_score,
-    get_mi_color,
-)
-
-FIXTURES_DIR = Path(__file__).parent.parent / "fixtures"
-
-
-def _make_entry(
-    current_input=0,
-    cache_creation=0,
-    cache_read=0,
-    total_output=0,
-    lines_added=0,
-    lines_removed=0,
-    context_window_size=200000,
-) -> StateEntry:
-    """Helper to create a StateEntry with sane defaults."""
-    return StateEntry(
-        timestamp=1000000,
-        total_input_tokens=0,
-        total_output_tokens=total_output,
-        current_input_tokens=current_input,
-        current_output_tokens=0,
-        cache_creation=cache_creation,
-        cache_read=cache_read,
-        cost_usd=0.0,
-        lines_added=lines_added,
-        lines_removed=lines_removed,
-        session_id="test",
-        model_id="test-model",
-        workspace_project_dir="/test",
-        context_window_size=context_window_size,
-    )
-
-
-# --- CPS tests ---
-
-
-class TestContextPressure:
-    def test_empty_context(self):
-        assert calculate_context_pressure(0.0) == 1.0
-
-    def test_full_context(self):
-        assert calculate_context_pressure(1.0) == 0.0
-
-    def test_half_context(self):
-        cps = calculate_context_pressure(0.5)
-        assert 0.64 < cps < 0.66  # ~0.646
-
-    def test_custom_beta_linear(self):
-        cps = calculate_context_pressure(0.5, beta=1.0)
-        assert cps == pytest.approx(0.5, abs=0.01)
-
-    def test_custom_beta_quadratic(self):
-        cps = calculate_context_pressure(0.5, beta=2.0)
-        assert cps == pytest.approx(0.75, abs=0.01)
-
-    def test_over_capacity_clamped(self):
-        cps = calculate_context_pressure(1.5)
-        assert cps == 0.0
-
-    def test_negative_utilization(self):
-        assert calculate_context_pressure(-0.1) == 1.0
-
-
-# --- CPS guard clause ---
-
-
-class TestGuardClause:
-    def test_zero_context_window(self):
-        entry = _make_entry(current_input=50000)
-        score = calculate_intelligence(entry, None, context_window_size=0)
-        assert score.mi == 1.0
-        assert score.cps == 1.0
-        assert score.es == 1.0
-        assert score.ps == 0.5
-        assert score.utilization == 0.0
-
-
-# --- ES tests ---
-
-
-class TestEfficiency:
-    def test_no_tokens(self):
-        entry = _make_entry()
-        assert calculate_efficiency(entry) == 1.0
-
-    def test_all_cache_read(self):
-        entry = _make_entry(cache_read=100000)
-        assert calculate_efficiency(entry) == 1.0
-
-    def test_no_cache(self):
-        entry = _make_entry(current_input=100000)
-        assert calculate_efficiency(entry) == pytest.approx(0.3, abs=0.01)
-
-    def test_mixed_cache(self):
-        # 60% cache read
-        entry = _make_entry(current_input=20000, cache_creation=20000, cache_read=60000)
-        es = calculate_efficiency(entry)
-        assert es == pytest.approx(0.3 + 0.7 * 0.6, abs=0.01)
-
-
-# --- PS tests ---
-
-
-class TestProductivity:
-    def test_no_previous_entry(self):
-        entry = _make_entry(total_output=1000, lines_added=100)
-        assert calculate_productivity(entry, None) == 0.5
-
-    def test_no_output(self):
-        prev = _make_entry(total_output=1000)
-        cur = _make_entry(total_output=1000)  # no increase
-        assert calculate_productivity(cur, prev) == 0.5
-
-    def test_high_productivity(self):
-        prev = _make_entry(total_output=0, lines_added=0, lines_removed=0)
-        cur = _make_entry(total_output=100, lines_added=20, lines_removed=5)
-        ps = calculate_productivity(cur, prev)
-        # ratio = 25/100 = 0.25, normalized = min(1, 0.25/0.2) = 1.0
-        assert ps == pytest.approx(1.0, abs=0.01)
-
-    def test_zero_productivity(self):
-        prev = _make_entry(total_output=0, lines_added=0, lines_removed=0)
-        cur = _make_entry(total_output=1000, lines_added=0, lines_removed=0)
-        ps = calculate_productivity(cur, prev)
-        assert ps == pytest.approx(0.2, abs=0.01)
-
-    def test_moderate_productivity(self):
-        prev = _make_entry(total_output=0, lines_added=0, lines_removed=0)
-        cur = _make_entry(total_output=1000, lines_added=50, lines_removed=10)
-        ps = calculate_productivity(cur, prev)
-        # ratio = 60/1000 = 0.06, normalized = min(1, 0.06/0.2) = 0.3
-        assert ps == pytest.approx(0.2 + 0.8 * 0.3, abs=0.01)
-
-    def test_capping(self):
-        prev = _make_entry(total_output=0, lines_added=0, lines_removed=0)
-        cur = _make_entry(total_output=10, lines_added=100, lines_removed=100)
-        ps = calculate_productivity(cur, prev)
-        # ratio = 200/10 = 20, normalized = min(1, 20/0.2) = 1.0
-        assert ps == pytest.approx(1.0, abs=0.01)
-
-    def test_consecutive_diffs(self):
-        """Verify PS uses consecutive entry diffs, not cumulative totals."""
-        prev = _make_entry(total_output=500, lines_added=50, lines_removed=10)
-        cur = _make_entry(total_output=600, lines_added=55, lines_removed=12)
-        ps = calculate_productivity(cur, prev)
-        # delta_lines = (55-50) + (12-10) = 7, delta_output = 100
-        # ratio = 7/100 = 0.07, normalized = 0.07/0.2 = 0.35
-        assert ps == pytest.approx(0.2 + 0.8 * 0.35, abs=0.01)
-
-
-# --- Composite tests ---
-
-
-class TestComposite:
-    def test_optimal_conditions(self):
-        prev = _make_entry(total_output=0, lines_added=0, lines_removed=0)
-        cur = _make_entry(
-            current_input=1000, cache_read=9000, total_output=100,
-            lines_added=25, lines_removed=5,
-        )
-        score = calculate_intelligence(cur, prev, 200000)
-        assert score.mi > 0.9
-
-    def test_worst_conditions(self):
-        prev = _make_entry(total_output=0, lines_added=0, lines_removed=0)
-        cur = _make_entry(
-            current_input=200000, total_output=10000,
-            lines_added=0, lines_removed=0,
-        )
-        score = calculate_intelligence(cur, prev, 200000)
-        assert score.mi < 0.2
-
-    def test_weight_sum(self):
-        assert MI_WEIGHT_CPS + MI_WEIGHT_ES + MI_WEIGHT_PS == pytest.approx(1.0)
-
-    def test_bounds(self):
-        """MI should always be in [0, 1]."""
-        prev = _make_entry(total_output=0)
-        for u in [0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 1.0]:
-            used = int(u * 200000)
-            cur = _make_entry(current_input=used, total_output=1000, lines_added=50)
-            score = calculate_intelligence(cur, prev, 200000)
-            assert 0.0 <= score.mi <= 1.0, f"MI out of bounds at u={u}: {score.mi}"
-
-
-# --- Color tests ---
-
-
-class TestColor:
-    def test_green(self):
-        assert get_mi_color(0.8) == "green"
-
-    def test_yellow(self):
-        assert get_mi_color(0.5) == "yellow"
-
-    def test_red(self):
-        assert get_mi_color(0.2) == "red"
-
-    def test_boundary_green(self):
-        assert get_mi_color(MI_GREEN_THRESHOLD + 0.001) == "green"
-
-    def test_boundary_yellow_upper(self):
-        assert get_mi_color(MI_GREEN_THRESHOLD) == "yellow"
-
-    def test_boundary_yellow_lower(self):
-        assert get_mi_color(MI_YELLOW_THRESHOLD + 0.001) == "yellow"
-
-    def test_boundary_red(self):
-        assert get_mi_color(MI_YELLOW_THRESHOLD) == "red"
-
-
-# --- Format tests ---
-
-
-class TestFormat:
-    def test_two_decimals(self):
-        assert format_mi_score(0.82) == "0.82"
-
-    def test_zero(self):
-        assert format_mi_score(0.0) == "0.00"
-
-    def test_one(self):
-        assert format_mi_score(1.0) == "1.00"
-
-    def test_rounding(self):
-        assert format_mi_score(0.8249) == "0.82"
-        assert format_mi_score(0.8251) == "0.83"
-
-
-# --- Shared test vectors ---
-
-
-class TestSharedVectors:
-    """Test against shared vectors for cross-implementation parity."""
-
-    @pytest.fixture
-    def vectors(self):
-        with open(FIXTURES_DIR / "mi_test_vectors.json") as f:
-            return json.load(f)
-
-    def test_all_vectors(self, vectors):
-        for vec in vectors:
-            inp = vec["input"]
-            exp = vec["expected"]
-
-            # Build entries from vector input
-            current_input = inp["current_input"]
-            cache_creation = inp["cache_creation"]
-            cache_read = inp["cache_read"]
-            # current_used should equal current_input + cache_creation + cache_read
-            # but we trust the vector's current_used for the entry construction
-            cur = _make_entry(
-                current_input=current_input,
-                cache_creation=cache_creation,
-                cache_read=cache_read,
-                total_output=inp["cur_output"],
-                lines_added=inp["cur_lines_added"],
-                lines_removed=inp["cur_lines_removed"],
-                context_window_size=inp["context_window"],
-            )
-
-            has_prev = inp["prev_output"] is not None
-            if has_prev:
-                prev = _make_entry(
-                    total_output=inp["prev_output"],
-                    lines_added=inp["prev_lines_added"],
-                    lines_removed=inp["prev_lines_removed"],
-                )
-            else:
-                prev = None
-
-            score = calculate_intelligence(
-                cur, prev, inp["context_window"], inp["beta"]
-            )
-
-            assert score.cps == pytest.approx(exp["cps"], abs=0.01), (
-                f"CPS mismatch for '{vec['description']}': "
-                f"got {score.cps}, expected {exp['cps']}"
-            )
-            assert score.es == pytest.approx(exp["es"], abs=0.01), (
-                f"ES mismatch for '{vec['description']}': "
-                f"got {score.es}, expected {exp['es']}"
-            )
-            assert score.ps == pytest.approx(exp["ps"], abs=0.01), (
-                f"PS mismatch for '{vec['description']}': "
-                f"got {score.ps}, expected {exp['ps']}"
-            )
-            assert score.mi == pytest.approx(exp["mi"], abs=0.01), (
-                f"MI mismatch for '{vec['description']}': "
-                f"got {score.mi}, expected {exp['mi']}"
-            )