cc-context-stats 1.5.1 → 1.6.0

package/tests/bash/test_parity.bats

@@ -0,0 +1,315 @@
+#!/usr/bin/env bats
+
+# Cross-implementation parity tests: Python vs Node.js statusline scripts
+# Ensures both implementations produce equivalent output for identical input.
+
+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"
+    FIXTURES="$PROJECT_ROOT/tests/fixtures/json"
+
+    # 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=120
+
+    # Disable delta display to avoid cross-fixture state file interference
+    mkdir -p "$TEST_HOME/.claude"
+    echo "show_delta=false" > "$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: inject a session_id into a JSON fixture via Python
+inject_session_py() {
+    local fixture="$1" session="$2"
+    python3 -c "
+import json, sys
+data = json.load(open('$fixture'))
+data['session_id'] = '$session'
+json.dump(data, sys.stdout)
+"
+}
+
+# Helper: inject a session_id into a JSON fixture via Node
+inject_session_node() {
+    local fixture="$1" session="$2"
+    node -e "
+const fs = require('fs');
+const data = JSON.parse(fs.readFileSync('$fixture', 'utf8'));
+data.session_id = '$session';
+process.stdout.write(JSON.stringify(data));
+"
+}
+
+# ============================================
+# Stdout Parity Tests
+# ============================================
+
+@test "stdout parity: Python and Node.js produce identical ANSI-stripped output for all fixtures" {
+    for fixture in "$FIXTURES"/*.json; do
+        fixture_name=$(basename "$fixture")
+
+        py_output=$(cat "$fixture" | python3 "$PYTHON_SCRIPT" 2>/dev/null)
+        node_output=$(cat "$fixture" | node "$NODE_SCRIPT" 2>/dev/null)
+
+        py_clean=$(strip_ansi "$py_output")
+        node_clean=$(strip_ansi "$node_output")
+
+        if [ "$py_clean" != "$node_clean" ]; then
+            echo "STDOUT MISMATCH for fixture: $fixture_name"
+            echo "---"
+            echo "Python output:  $py_clean"
+            echo "Node.js output: $node_clean"
+            echo "---"
+            return 1
+        fi
+    done
+}
+
+# ============================================
+# CSV State File Parity Tests
+# ============================================
+
+@test "CSV parity: both scripts write exactly 14 fields for all fixtures" {
+    for fixture in "$FIXTURES"/*.json; do
+        fixture_name=$(basename "$fixture" .json)
+
+        py_session="parity-py-${fixture_name}"
+        node_session="parity-node-${fixture_name}"
+
+        py_input=$(inject_session_py "$fixture" "$py_session")
+        node_input=$(inject_session_node "$fixture" "$node_session")
+
+        echo "$py_input" | python3 "$PYTHON_SCRIPT" > /dev/null 2>&1
+        echo "$node_input" | node "$NODE_SCRIPT" > /dev/null 2>&1
+
+        py_state_file="$TEST_HOME/.claude/statusline/statusline.${py_session}.state"
+        node_state_file="$TEST_HOME/.claude/statusline/statusline.${node_session}.state"
+
+        # Skip fixtures that don't produce state files (e.g., no context_window data)
+        if [ ! -f "$py_state_file" ] && [ ! -f "$node_state_file" ]; then
+            continue
+        fi
+
+        # If only one script wrote a state file, that's a parity failure
+        if [ ! -f "$py_state_file" ]; then
+            echo "PARITY ERROR for fixture: $fixture_name"
+            echo "Node.js wrote a state file but Python did not"
+            return 1
+        fi
+        if [ ! -f "$node_state_file" ]; then
+            echo "PARITY ERROR for fixture: $fixture_name"
+            echo "Python wrote a state file but Node.js did not"
+            return 1
+        fi
+
+        # Read last line of each state file
+        py_line=$(tail -1 "$py_state_file")
+        node_line=$(tail -1 "$node_state_file")
+
+        # Count fields (comma-separated)
+        py_field_count=$(echo "$py_line" | awk -F',' '{print NF}')
+        node_field_count=$(echo "$node_line" | awk -F',' '{print NF}')
+
+        if [ "$py_field_count" -ne 14 ]; then
+            echo "FIELD COUNT ERROR for fixture: $fixture_name"
+            echo "Python state has $py_field_count fields (expected 14)"
+            echo "Python line: $py_line"
+            return 1
+        fi
+        if [ "$node_field_count" -ne 14 ]; then
+            echo "FIELD COUNT ERROR for fixture: $fixture_name"
+            echo "Node.js state has $node_field_count fields (expected 14)"
+            echo "Node.js line: $node_line"
+            return 1
+        fi
+    done
+}
+
+@test "CSV parity: fields 1-13 match between Python and Node.js for all fixtures" {
+    # Field names for diagnostic output (index 0 = timestamp, 1-13 = data fields)
+    local field_names=(
+        "timestamp"
+        "total_input_tokens"
+        "total_output_tokens"
+        "current_usage_input_tokens"
+        "current_usage_output_tokens"
+        "current_usage_cache_creation"
+        "current_usage_cache_read"
+        "total_cost_usd"
+        "total_lines_added"
+        "total_lines_removed"
+        "session_id"
+        "model_id"
+        "workspace_project_dir"
+        "context_window_size"
+    )
+
+    for fixture in "$FIXTURES"/*.json; do
+        fixture_name=$(basename "$fixture" .json)
+
+        py_session="parity-fields-py-${fixture_name}"
+        node_session="parity-fields-node-${fixture_name}"
+
+        py_input=$(inject_session_py "$fixture" "$py_session")
+        node_input=$(inject_session_node "$fixture" "$node_session")
+
+        echo "$py_input" | python3 "$PYTHON_SCRIPT" > /dev/null 2>&1
+        echo "$node_input" | node "$NODE_SCRIPT" > /dev/null 2>&1
+
+        py_state_file="$TEST_HOME/.claude/statusline/statusline.${py_session}.state"
+        node_state_file="$TEST_HOME/.claude/statusline/statusline.${node_session}.state"
+
+        # Skip fixtures that don't produce state files
+        if [ ! -f "$py_state_file" ] && [ ! -f "$node_state_file" ]; then
+            continue
+        fi
+
+        [ -f "$py_state_file" ] || { echo "Python wrote no state file but Node did for $fixture_name"; return 1; }
+        [ -f "$node_state_file" ] || { echo "Node wrote no state file but Python did for $fixture_name"; return 1; }
+
+        py_line=$(tail -1 "$py_state_file")
+        node_line=$(tail -1 "$node_state_file")
+
+        # Compare fields 1-13 (skip timestamp at index 0, and skip session_id at index 10 since we set different ones)
+        local has_mismatch=0
+        for i in $(seq 1 13); do
+            # Skip field 10 (session_id) since we intentionally set different session IDs
+            if [ "$i" -eq 10 ]; then
+                continue
+            fi
+
+            py_field=$(echo "$py_line" | cut -d',' -f$((i + 1)))
+            node_field=$(echo "$node_line" | cut -d',' -f$((i + 1)))
+
+            if [ "$py_field" != "$node_field" ]; then
+                echo "FIELD MISMATCH for fixture: $fixture_name"
+                echo "  Field $i (${field_names[$i]}): Python='$py_field' Node='$node_field'"
+                has_mismatch=1
+            fi
+        done
+
+        if [ "$has_mismatch" -eq 1 ]; then
+            echo "Full Python line:  $py_line"
+            echo "Full Node.js line: $node_line"
+            return 1
+        fi
+    done
+}
+
+@test "CSV parity: comma in workspace_project_dir is sanitized to underscore" {
+    fixture="$FIXTURES/comma_in_path.json"
+    [ -f "$fixture" ] || skip "comma_in_path.json fixture missing"
+
+    # Enable show_delta so state files are written
+    echo "show_delta=true" > "$TEST_HOME/.claude/statusline.conf"
+
+    py_session="parity-comma-py"
+    node_session="parity-comma-node"
+
+    py_input=$(inject_session_py "$fixture" "$py_session")
+    node_input=$(inject_session_node "$fixture" "$node_session")
+
+    echo "$py_input" | python3 "$PYTHON_SCRIPT" > /dev/null 2>&1
+    echo "$node_input" | node "$NODE_SCRIPT" > /dev/null 2>&1
+
+    # Restore show_delta=false for subsequent tests
+    echo "show_delta=false" > "$TEST_HOME/.claude/statusline.conf"
+
+    py_state_file="$TEST_HOME/.claude/statusline/statusline.${py_session}.state"
+    node_state_file="$TEST_HOME/.claude/statusline/statusline.${node_session}.state"
+
+    [ -f "$py_state_file" ] || { echo "Python wrote no state file"; return 1; }
+    [ -f "$node_state_file" ] || { echo "Node wrote no state file"; return 1; }
+
+    # Extract workspace_project_dir (field 13, 1-indexed in cut)
+    py_dir=$(tail -1 "$py_state_file" | cut -d',' -f13)
+    node_dir=$(tail -1 "$node_state_file" | cut -d',' -f13)
+
+    # Both must have commas replaced with underscores
+    expected="/home/user/my_project_dir"
+
+    if [ "$py_dir" != "$expected" ]; then
+        echo "Python did not sanitize commas: got '$py_dir', expected '$expected'"
+        return 1
+    fi
+    if [ "$node_dir" != "$expected" ]; then
+        echo "Node.js did not sanitize commas: got '$node_dir', expected '$expected'"
+        return 1
+    fi
+
+    # Both must produce exactly 14 fields (commas didn't corrupt the CSV)
+    py_fields=$(tail -1 "$py_state_file" | awk -F',' '{print NF}')
+    node_fields=$(tail -1 "$node_state_file" | awk -F',' '{print NF}')
+
+    if [ "$py_fields" -ne 14 ]; then
+        echo "Python state has $py_fields fields (expected 14)"
+        return 1
+    fi
+    if [ "$node_fields" -ne 14 ]; then
+        echo "Node.js state has $node_fields fields (expected 14)"
+        return 1
+    fi
+}
+
+@test "CSV parity: timestamp differs by at most 2 seconds between Python and Node.js" {
+    for fixture in "$FIXTURES"/*.json; do
+        fixture_name=$(basename "$fixture" .json)
+
+        py_session="parity-ts-py-${fixture_name}"
+        node_session="parity-ts-node-${fixture_name}"
+
+        py_input=$(inject_session_py "$fixture" "$py_session")
+        node_input=$(inject_session_node "$fixture" "$node_session")
+
+        echo "$py_input" | python3 "$PYTHON_SCRIPT" > /dev/null 2>&1
+        echo "$node_input" | node "$NODE_SCRIPT" > /dev/null 2>&1
+
+        py_state_file="$TEST_HOME/.claude/statusline/statusline.${py_session}.state"
+        node_state_file="$TEST_HOME/.claude/statusline/statusline.${node_session}.state"
+
+        # Skip fixtures that don't produce state files
+        if [ ! -f "$py_state_file" ] && [ ! -f "$node_state_file" ]; then
+            continue
+        fi
+
+        [ -f "$py_state_file" ] || { echo "Python wrote no state file but Node did for $fixture_name"; return 1; }
+        [ -f "$node_state_file" ] || { echo "Node wrote no state file but Python did for $fixture_name"; return 1; }
+
+        py_line=$(tail -1 "$py_state_file")
+        node_line=$(tail -1 "$node_state_file")
+
+        # Extract timestamp (field 0, which is field 1 in cut 1-indexed)
+        py_ts=$(echo "$py_line" | cut -d',' -f1)
+        node_ts=$(echo "$node_line" | cut -d',' -f1)
+
+        # Calculate absolute difference
+        if [ -n "$py_ts" ] && [ -n "$node_ts" ]; then
+            diff=$((py_ts - node_ts))
+            abs_diff=${diff#-}
+
+            if [ "$abs_diff" -gt 2 ]; then
+                echo "TIMESTAMP DRIFT for fixture: $fixture_name"
+                echo "  Python timestamp:  $py_ts"
+                echo "  Node.js timestamp: $node_ts"
+                echo "  Difference: ${abs_diff}s (max allowed: 2s)"
+                return 1
+            fi
+        fi
+    done
+}

package/tests/fixtures/json/comma_in_path.json

@@ -0,0 +1,31 @@
+{
+  "model": {
+    "display_name": "Opus 4.5",
+    "api_name": "claude-opus-4-5",
+    "id": "claude-opus-4-5"
+  },
+  "workspace": {
+    "current_dir": "/home/user/my,project,dir",
+    "project_dir": "/home/user/my,project,dir"
+  },
+  "context_window": {
+    "context_window_size": 200000,
+    "total_input_tokens": 75000,
+    "total_output_tokens": 8500,
+    "current_usage": {
+      "input_tokens": 50000,
+      "output_tokens": 5000,
+      "cache_creation_input_tokens": 10000,
+      "cache_read_input_tokens": 20000
+    }
+  },
+  "cost": {
+    "total_cost_usd": 0.05234,
+    "total_duration_ms": 120000,
+    "total_api_duration_ms": 5000,
+    "total_lines_added": 250,
+    "total_lines_removed": 45
+  },
+  "session_id": "test-comma-path",
+  "version": "1.0.80"
+}

package/tests/node/rotation.test.js

@@ -0,0 +1,89 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Import rotation function from statusline.js
+// The script reads stdin on require, so we mock stdin to prevent hanging
+const originalStdin = process.stdin;
+
+// Prevent the script's stdin listener from blocking
+jest.spyOn(process.stdin, 'setEncoding').mockImplementation(() => {});
+jest.spyOn(process.stdin, 'on').mockImplementation(() => {});
+
+const { maybeRotateStateFile, ROTATION_THRESHOLD, ROTATION_KEEP } = require('../../scripts/statusline.js');
+
+function makeCsvLine(index) {
+    return `${1710288000 + index},100,200,300,400,500,600,0.01,10,5,sess-${index},model,/tmp/proj,200000`;
+}
+
+describe('maybeRotateStateFile', () => {
+    let tmpDir;
+    let stateFile;
+
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rotation-test-'));
+        stateFile = path.join(tmpDir, 'test.state');
+    });
+
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    test('file below threshold is not rotated', () => {
+        const lines = Array.from({ length: 9999 }, (_, i) => makeCsvLine(i));
+        fs.writeFileSync(stateFile, lines.join('\n') + '\n');
+
+        maybeRotateStateFile(stateFile);
+
+        const result = fs.readFileSync(stateFile, 'utf8').trim().split('\n');
+        expect(result.length).toBe(9999);
+    });
+
+    test('file at exactly threshold is not rotated', () => {
+        const lines = Array.from({ length: ROTATION_THRESHOLD }, (_, i) => makeCsvLine(i));
+        fs.writeFileSync(stateFile, lines.join('\n') + '\n');
+
+        maybeRotateStateFile(stateFile);
+
+        const result = fs.readFileSync(stateFile, 'utf8').trim().split('\n');
+        expect(result.length).toBe(ROTATION_THRESHOLD);
+    });
+
+    test('file exceeding threshold is truncated to ROTATION_KEEP lines', () => {
+        const lines = Array.from({ length: 10001 }, (_, i) => makeCsvLine(i));
+        fs.writeFileSync(stateFile, lines.join('\n') + '\n');
+
+        maybeRotateStateFile(stateFile);
+
+        const result = fs.readFileSync(stateFile, 'utf8').trim().split('\n');
+        expect(result.length).toBe(ROTATION_KEEP);
+    });
+
+    test('retained lines are the most recent', () => {
+        const total = 10001;
+        const lines = Array.from({ length: total }, (_, i) => makeCsvLine(i));
+        fs.writeFileSync(stateFile, lines.join('\n') + '\n');
+
+        maybeRotateStateFile(stateFile);
+
+        const result = fs.readFileSync(stateFile, 'utf8').trim().split('\n');
+        // First retained line should be index (total - ROTATION_KEEP)
+        expect(result[0]).toContain(`sess-${total - ROTATION_KEEP}`);
+        // Last retained line should be the last original line
+        expect(result[result.length - 1]).toContain(`sess-${total - 1}`);
+    });
+
+    test('non-existent file does not throw', () => {
+        expect(() => maybeRotateStateFile('/tmp/nonexistent-rotation-test.state')).not.toThrow();
+    });
+
+    test('no temp files remain after rotation', () => {
+        const lines = Array.from({ length: 10001 }, (_, i) => makeCsvLine(i));
+        fs.writeFileSync(stateFile, lines.join('\n') + '\n');
+
+        maybeRotateStateFile(stateFile);
+
+        const tmpFiles = fs.readdirSync(tmpDir).filter(f => f.endsWith('.tmp'));
+        expect(tmpFiles.length).toBe(0);
+    });
+});