cc-context-stats 1.3.0

package/tests/fixtures/json/valid_full.json

@@ -0,0 +1,30 @@
+{
+  "model": {
+    "display_name": "Opus 4.5",
+    "api_name": "claude-opus-4-5"
+  },
+  "workspace": {
+    "current_dir": "/home/user/my-project",
+    "project_dir": "/home/user/my-project"
+  },
+  "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-session-123",
+  "version": "1.0.80"
+}

package/tests/fixtures/json/valid_minimal.json

@@ -0,0 +1,9 @@
+{
+  "model": {
+    "display_name": "Claude"
+  },
+  "workspace": {
+    "current_dir": "/tmp/test",
+    "project_dir": "/tmp/test"
+  }
+}

package/tests/node/statusline.test.js

@@ -0,0 +1,199 @@
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const SCRIPT_PATH = path.join(__dirname, '..', '..', 'scripts', 'statusline.js');
+const FIXTURES_DIR = path.join(__dirname, '..', 'fixtures', 'json');
+
+/**
+ * Run the statusline.js script with the given input data
+ * @param {Object|string} inputData - JSON input or string
+ * @returns {Promise<{stdout: string, stderr: string, code: number}>}
+ */
+function runScript(inputData) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('node', [SCRIPT_PATH]);
+        let stdout = '';
+        let stderr = '';
+
+        child.stdout.on('data', data => {
+            stdout += data.toString();
+        });
+
+        child.stderr.on('data', data => {
+            stderr += data.toString();
+        });
+
+        child.on('close', code => {
+            resolve({ stdout: stdout.trim(), stderr, code });
+        });
+
+        child.on('error', reject);
+
+        const input = typeof inputData === 'string' ? inputData : JSON.stringify(inputData);
+        child.stdin.write(input);
+        child.stdin.end();
+    });
+}
+
+/**
+ * Load a JSON fixture file
+ * @param {string} name - Fixture name without .json extension
+ * @returns {Object}
+ */
+function loadFixture(name) {
+    const filePath = path.join(FIXTURES_DIR, `${name}.json`);
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+describe('statusline.js', () => {
+    const sampleInput = {
+        model: { display_name: 'Claude 3.5 Sonnet' },
+        workspace: {
+            current_dir: '/home/user/myproject',
+            project_dir: '/home/user/myproject',
+        },
+        context_window: {
+            context_window_size: 200000,
+            current_usage: {
+                input_tokens: 10000,
+                cache_creation_input_tokens: 500,
+                cache_read_input_tokens: 200,
+            },
+        },
+    };
+
+    describe('Script basics', () => {
+        test('script file exists', () => {
+            expect(fs.existsSync(SCRIPT_PATH)).toBe(true);
+        });
+
+        test('script has node shebang', () => {
+            const content = fs.readFileSync(SCRIPT_PATH, 'utf8');
+            expect(content.startsWith('#!/usr/bin/env node')).toBe(true);
+        });
+    });
+
+    describe('Output content', () => {
+        test('outputs model name', async () => {
+            const result = await runScript(sampleInput);
+            expect(result.stdout).toContain('Claude 3.5 Sonnet');
+            expect(result.code).toBe(0);
+        });
+
+        test('outputs directory name', async () => {
+            const result = await runScript(sampleInput);
+            expect(result.stdout).toContain('myproject');
+        });
+
+        test('shows free tokens indicator', async () => {
+            const result = await runScript(sampleInput);
+            expect(result.stdout).toContain('free');
+        });
+
+        test('shows AC indicator', async () => {
+            const result = await runScript(sampleInput);
+            expect(result.stdout).toContain('[AC:');
+        });
+
+        test('shows percentage', async () => {
+            const result = await runScript(sampleInput);
+            expect(result.stdout).toMatch(/\d+\.\d+%/);
+        });
+    });
+
+    describe('Error handling', () => {
+        test('handles missing model gracefully', async () => {
+            const input = {
+                workspace: { current_dir: '/tmp/test', project_dir: '/tmp/test' },
+            };
+            const result = await runScript(input);
+            expect(result.stdout).toContain('Claude'); // Default fallback
+            expect(result.code).toBe(0);
+        });
+
+        test('handles missing context window gracefully', async () => {
+            const input = {
+                model: { display_name: 'Claude' },
+                workspace: { current_dir: '/tmp/test', project_dir: '/tmp/test' },
+            };
+            const result = await runScript(input);
+            expect(result.code).toBe(0);
+        });
+
+        test('handles invalid JSON gracefully', async () => {
+            const result = await runScript('invalid json');
+            expect(result.code).toBe(0);
+            expect(result.stdout).toContain('Claude');
+        });
+
+        test('handles empty input gracefully', async () => {
+            const result = await runScript('');
+            expect(result.code).toBe(0);
+        });
+    });
+
+    describe('Fixtures', () => {
+        test('handles valid_full fixture', async () => {
+            const input = loadFixture('valid_full');
+            const result = await runScript(input);
+            expect(result.code).toBe(0);
+            expect(result.stdout).toContain('Opus 4.5');
+            expect(result.stdout).toContain('my-project');
+        });
+
+        test('handles valid_minimal fixture', async () => {
+            const input = loadFixture('valid_minimal');
+            const result = await runScript(input);
+            expect(result.code).toBe(0);
+            expect(result.stdout).toContain('Claude');
+        });
+
+        test('handles low_usage fixture', async () => {
+            const input = loadFixture('low_usage');
+            const result = await runScript(input);
+            expect(result.code).toBe(0);
+            expect(result.stdout).toContain('free');
+        });
+
+        test('handles medium_usage fixture', async () => {
+            const input = loadFixture('medium_usage');
+            const result = await runScript(input);
+            expect(result.code).toBe(0);
+            expect(result.stdout).toContain('free');
+        });
+
+        test('handles high_usage fixture', async () => {
+            const input = loadFixture('high_usage');
+            const result = await runScript(input);
+            expect(result.code).toBe(0);
+            expect(result.stdout).toContain('free');
+        });
+
+        test('all JSON fixtures succeed', async () => {
+            const fixtures = fs.readdirSync(FIXTURES_DIR).filter(f => f.endsWith('.json'));
+            for (const fixture of fixtures) {
+                const input = JSON.parse(fs.readFileSync(path.join(FIXTURES_DIR, fixture), 'utf8'));
+                const result = await runScript(input);
+                expect(result.code).toBe(0);
+            }
+        });
+    });
+
+    describe('Session ID display', () => {
+        test('shows session_id by default', async () => {
+            const inputWithSession = {
+                ...sampleInput,
+                session_id: 'test-session-abc123',
+            };
+            const result = await runScript(inputWithSession);
+            expect(result.code).toBe(0);
+            expect(result.stdout).toContain('test-session-abc123');
+        });
+
+        test('handles missing session_id gracefully', async () => {
+            const result = await runScript(sampleInput);
+            expect(result.code).toBe(0);
+        });
+    });
+});

package/tests/python/conftest.py

@@ -0,0 +1,84 @@
+"""Pytest configuration and fixtures for statusline tests."""
+
+import json
+from pathlib import Path
+
+import pytest
+
+# Get the project root directory
+PROJECT_ROOT = Path(__file__).parent.parent.parent
+FIXTURES_DIR = PROJECT_ROOT / "tests" / "fixtures" / "json"
+SCRIPTS_DIR = PROJECT_ROOT / "scripts"
+
+
+@pytest.fixture
+def project_root():
+    """Return the project root directory."""
+    return PROJECT_ROOT
+
+
+@pytest.fixture
+def scripts_dir():
+    """Return the scripts directory."""
+    return SCRIPTS_DIR
+
+
+@pytest.fixture
+def fixtures_dir():
+    """Return the fixtures directory."""
+    return FIXTURES_DIR
+
+
+@pytest.fixture
+def valid_full_input():
+    """Load valid_full.json fixture."""
+    with open(FIXTURES_DIR / "valid_full.json") as f:
+        return json.load(f)
+
+
+@pytest.fixture
+def valid_minimal_input():
+    """Load valid_minimal.json fixture."""
+    with open(FIXTURES_DIR / "valid_minimal.json") as f:
+        return json.load(f)
+
+
+@pytest.fixture
+def low_usage_input():
+    """Load low_usage.json fixture."""
+    with open(FIXTURES_DIR / "low_usage.json") as f:
+        return json.load(f)
+
+
+@pytest.fixture
+def medium_usage_input():
+    """Load medium_usage.json fixture."""
+    with open(FIXTURES_DIR / "medium_usage.json") as f:
+        return json.load(f)
+
+
+@pytest.fixture
+def high_usage_input():
+    """Load high_usage.json fixture."""
+    with open(FIXTURES_DIR / "high_usage.json") as f:
+        return json.load(f)
+
+
+@pytest.fixture
+def sample_input():
+    """Return a sample input dictionary for testing."""
+    return {
+        "model": {"display_name": "Claude 3.5 Sonnet"},
+        "workspace": {
+            "current_dir": "/home/user/myproject",
+            "project_dir": "/home/user/myproject",
+        },
+        "context_window": {
+            "context_window_size": 200000,
+            "current_usage": {
+                "input_tokens": 10000,
+                "cache_creation_input_tokens": 500,
+                "cache_read_input_tokens": 200,
+            },
+        },
+    }

package/tests/python/test_statusline.py

@@ -0,0 +1,154 @@
+"""Tests for statusline.py script."""
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+SCRIPT_PATH = Path(__file__).parent.parent.parent / "scripts" / "statusline.py"
+
+
+def run_script(input_data: dict) -> tuple[str, int]:
+    """Run the statusline.py script with the given input.
+
+    Returns:
+        Tuple of (stdout, return_code)
+    """
+    result = subprocess.run(
+        [sys.executable, str(SCRIPT_PATH)],
+        input=json.dumps(input_data),
+        capture_output=True,
+        text=True,
+    )
+    return result.stdout.strip(), result.returncode
+
+
+class TestStatuslineScript:
+    """Tests for the statusline.py script execution."""
+
+    def test_script_exists(self):
+        """Script file should exist."""
+        assert SCRIPT_PATH.exists()
+
+    def test_script_is_python(self):
+        """Script should have Python shebang."""
+        content = SCRIPT_PATH.read_text()
+        assert content.startswith("#!/usr/bin/env python3")
+
+    def test_outputs_model_name(self, sample_input):
+        """Should output the model name."""
+        output, code = run_script(sample_input)
+        assert code == 0
+        assert "Claude 3.5 Sonnet" in output
+
+    def test_outputs_directory_name(self, sample_input):
+        """Should output the directory name."""
+        output, code = run_script(sample_input)
+        assert code == 0
+        assert "myproject" in output
+
+    def test_shows_free_tokens(self, sample_input):
+        """Should show free tokens indicator."""
+        output, code = run_script(sample_input)
+        assert code == 0
+        assert "free" in output
+
+    def test_shows_ac_indicator(self, sample_input):
+        """Should show autocompact indicator."""
+        output, code = run_script(sample_input)
+        assert code == 0
+        assert "[AC:" in output
+
+    def test_handles_missing_model(self):
+        """Should handle missing model gracefully."""
+        input_data = {"workspace": {"current_dir": "/tmp/test", "project_dir": "/tmp/test"}}
+        output, code = run_script(input_data)
+        assert code == 0
+        assert "Claude" in output  # Default fallback
+
+    def test_handles_invalid_json(self):
+        """Should handle invalid JSON gracefully."""
+        result = subprocess.run(
+            [sys.executable, str(SCRIPT_PATH)],
+            input="invalid json",
+            capture_output=True,
+            text=True,
+        )
+        assert result.returncode == 0
+        assert "Claude" in result.stdout
+
+    def test_handles_empty_input(self):
+        """Should handle empty input gracefully."""
+        result = subprocess.run(
+            [sys.executable, str(SCRIPT_PATH)],
+            input="",
+            capture_output=True,
+            text=True,
+        )
+        assert result.returncode == 0
+
+
+class TestContextWindowColors:
+    """Tests for context window color coding."""
+
+    def test_low_usage_has_output(self, low_usage_input):
+        """Low usage (>50% free) should produce output with 'free'."""
+        output, code = run_script(low_usage_input)
+        assert code == 0
+        assert "free" in output
+
+    def test_medium_usage_has_output(self, medium_usage_input):
+        """Medium usage (25-50% free) should produce output with 'free'."""
+        output, code = run_script(medium_usage_input)
+        assert code == 0
+        assert "free" in output
+
+    def test_high_usage_has_output(self, high_usage_input):
+        """High usage (<25% free) should produce output with 'free'."""
+        output, code = run_script(high_usage_input)
+        assert code == 0
+        assert "free" in output
+
+
+class TestFixtures:
+    """Tests using fixture files."""
+
+    def test_valid_full_fixture(self, valid_full_input):
+        """Should handle valid_full.json fixture."""
+        output, code = run_script(valid_full_input)
+        assert code == 0
+        assert "Opus 4.5" in output
+        assert "my-project" in output
+
+    def test_valid_minimal_fixture(self, valid_minimal_input):
+        """Should handle valid_minimal.json fixture."""
+        output, code = run_script(valid_minimal_input)
+        assert code == 0
+        assert "Claude" in output
+
+    def test_all_fixtures_succeed(self, fixtures_dir):
+        """All JSON fixtures should be processed without errors."""
+        for fixture_file in fixtures_dir.glob("*.json"):
+            with open(fixture_file) as f:
+                input_data = json.load(f)
+            output, code = run_script(input_data)
+            assert code == 0, f"Failed on fixture: {fixture_file.name}"
+
+
+class TestSessionDisplay:
+    """Tests for session_id display feature."""
+
+    def test_shows_session_id_by_default(self, sample_input):
+        """Should show session_id by default (show_session=true)."""
+        sample_input["session_id"] = "test-session-12345"
+        output, code = run_script(sample_input)
+        assert code == 0
+        assert "test-session-12345" in output
+
+    def test_handles_missing_session_id(self, sample_input):
+        """Should handle missing session_id gracefully."""
+        # Ensure no session_id in input
+        if "session_id" in sample_input:
+            del sample_input["session_id"]
+        output, code = run_script(sample_input)
+        assert code == 0