@jacques-ai/cli 0.0.7-alpha.1

package/hooks/adapters/test_calibration.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+"""
+test_calibration.py - Unit tests for calibration module
+
+Run with:
+  python3 hooks/adapters/test_calibration.py
+"""
+import sys
+import os
+import tempfile
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from adapters import calibration
+
+
+def setup_test_calibration():
+    """Reset calibration state for testing."""
+    # Reset in-memory cache
+    calibration._calibration_cache = None
+    calibration._cache_loaded = False
+    
+    # Use temporary file for tests
+    calibration.CALIBRATION_PATH = Path(tempfile.mktemp(suffix='.json'))
+
+
+def teardown_test_calibration():
+    """Clean up test calibration file."""
+    if calibration.CALIBRATION_PATH.exists():
+        os.unlink(calibration.CALIBRATION_PATH)
+
+
+def test_get_factor_default():
+    """Test that default factor is 1.0."""
+    setup_test_calibration()
+    try:
+        factor = calibration.get_factor('new-session')
+        assert factor == 1.0
+    finally:
+        teardown_test_calibration()
+
+
+def test_set_and_get_factor():
+    """Test setting and getting a correction factor."""
+    setup_test_calibration()
+    try:
+        calibration.set_factor('test-session', 1.15)
+        factor = calibration.get_factor('test-session')
+        assert factor == 1.15
+    finally:
+        teardown_test_calibration()
+
+
+def test_factor_clamping_high():
+    """Test that factor is clamped to maximum 2.0."""
+    setup_test_calibration()
+    try:
+        calibration.set_factor('test-session', 3.0)
+        factor = calibration.get_factor('test-session')
+        assert factor == 2.0
+    finally:
+        teardown_test_calibration()
+
+
+def test_factor_clamping_low():
+    """Test that factor is clamped to minimum 0.5."""
+    setup_test_calibration()
+    try:
+        calibration.set_factor('test-session', 0.2)
+        factor = calibration.get_factor('test-session')
+        assert factor == 0.5
+    finally:
+        teardown_test_calibration()
+
+
+def test_set_and_get_last_estimate():
+    """Test storing and retrieving last estimate."""
+    setup_test_calibration()
+    try:
+        calibration.set_last_estimate('test-session', 50000)
+        estimate = calibration.get_last_estimate('test-session')
+        assert estimate == 50000
+    finally:
+        teardown_test_calibration()
+
+
+def test_get_last_estimate_missing():
+    """Test that missing estimate returns None."""
+    setup_test_calibration()
+    try:
+        estimate = calibration.get_last_estimate('nonexistent-session')
+        assert estimate is None
+    finally:
+        teardown_test_calibration()
+
+
+def test_calibrate_from_actual():
+    """Test calibration from actual token count."""
+    setup_test_calibration()
+    try:
+        # Store an estimate
+        calibration.set_last_estimate('test-session', 10000)
+        
+        # Calibrate with actual (10% higher)
+        factor = calibration.calibrate_from_actual('test-session', 11000)
+        
+        assert factor == 1.1
+        
+        # Verify factor is stored
+        stored_factor = calibration.get_factor('test-session')
+        assert stored_factor == 1.1
+    finally:
+        teardown_test_calibration()
+
+
+def test_calibrate_no_estimate():
+    """Test that calibration returns None when no estimate available."""
+    setup_test_calibration()
+    try:
+        factor = calibration.calibrate_from_actual('new-session', 50000)
+        assert factor is None
+    finally:
+        teardown_test_calibration()
+
+
+def test_clear_session():
+    """Test clearing session calibration data."""
+    setup_test_calibration()
+    try:
+        # Set some data
+        calibration.set_factor('test-session', 1.2)
+        calibration.set_last_estimate('test-session', 50000)
+        
+        # Verify data is set
+        assert calibration.get_last_estimate('test-session') == 50000
+        assert calibration.get_factor('test-session') == 1.2
+        
+        # Clear session
+        calibration.clear_session('test-session')
+        
+        # Session-specific data should be gone
+        estimate = calibration.get_last_estimate('test-session')
+        assert estimate is None, "Estimate should be cleared"
+        
+        # get_factor falls back to global_factor (which is 1.2 from when it was set)
+        # This is expected behavior - global factor persists as a fallback
+        factor = calibration.get_factor('test-session')
+        assert factor >= 0.5 and factor <= 2.0, "Factor should be in valid range"
+    finally:
+        teardown_test_calibration()
+
+
+def test_persistence():
+    """Test that calibration data persists across loads."""
+    setup_test_calibration()
+    try:
+        # Set data
+        calibration.set_factor('test-session', 1.25)
+        
+        # Reset cache to force reload
+        calibration._calibration_cache = None
+        calibration._cache_loaded = False
+        
+        # Should load from file
+        factor = calibration.get_factor('test-session')
+        assert factor == 1.25
+    finally:
+        teardown_test_calibration()
+
+
+def test_get_calibration_stats():
+    """Test getting calibration statistics."""
+    setup_test_calibration()
+    try:
+        # Add some sessions
+        calibration.set_factor('session-1', 1.1)
+        calibration.set_factor('session-2', 1.2)
+        calibration.set_last_estimate('session-3', 50000)  # No factor
+        
+        stats = calibration.get_calibration_stats()
+        
+        assert stats['session_count'] == 3
+        assert stats['calibrated_sessions'] == 2  # Only 2 have factors
+        assert 1.0 <= stats['global_factor'] <= 1.5  # Should be average
+    finally:
+        teardown_test_calibration()
+
+
+def run_tests():
+    """Run all tests without pytest."""
+    import traceback
+    
+    tests = [
+        test_get_factor_default,
+        test_set_and_get_factor,
+        test_factor_clamping_high,
+        test_factor_clamping_low,
+        test_set_and_get_last_estimate,
+        test_get_last_estimate_missing,
+        test_calibrate_from_actual,
+        test_calibrate_no_estimate,
+        test_clear_session,
+        test_persistence,
+        test_get_calibration_stats,
+    ]
+    
+    passed = 0
+    failed = 0
+    
+    print("=" * 60)
+    print("Running Calibration Tests")
+    print("=" * 60)
+    
+    for test in tests:
+        try:
+            test()
+            print(f"  ✓ {test.__name__}")
+            passed += 1
+        except AssertionError as e:
+            print(f"  ✗ {test.__name__}: {e}")
+            failed += 1
+        except Exception as e:
+            print(f"  ✗ {test.__name__}: {type(e).__name__}: {e}")
+            traceback.print_exc()
+            failed += 1
+    
+    print(f"\nResults: {passed}/{passed + failed} passed, {failed} failed")
+    return failed == 0
+
+
+if __name__ == '__main__':
+    success = run_tests()
+    sys.exit(0 if success else 1)

package/hooks/adapters/test_skills.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+"""
+test_skills.py - Unit tests for skills detection module
+
+Run with:
+  python3 hooks/adapters/test_skills.py
+"""
+import sys
+import tempfile
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from adapters import skills
+
+
+def test_find_skill_files():
+    """Test that skill files can be found."""
+    skill_files = skills.find_skill_files()
+    
+    # Should find some skills (user has skills installed)
+    assert isinstance(skill_files, list)
+    # All should be Path objects
+    for f in skill_files:
+        assert isinstance(f, Path)
+
+
+def test_estimate_skill_tokens():
+    """Test skill token estimation."""
+    skills.clear_cache()
+    skill_count, estimated_tokens = skills.estimate_skill_tokens()
+    
+    assert isinstance(skill_count, int)
+    assert isinstance(estimated_tokens, int)
+    assert skill_count >= 0
+    assert estimated_tokens >= 0
+    
+    # If skills are found, tokens should be positive
+    if skill_count > 0:
+        assert estimated_tokens > 0
+
+
+def test_estimate_skill_tokens_caching():
+    """Test that skill estimation is cached."""
+    skills.clear_cache()
+    
+    # First call
+    count1, tokens1 = skills.estimate_skill_tokens()
+    
+    # Second call should return same values (cached)
+    count2, tokens2 = skills.estimate_skill_tokens()
+    
+    assert count1 == count2
+    assert tokens1 == tokens2
+
+
+def test_get_initial_context_estimate():
+    """Test initial context estimate calculation."""
+    skills.clear_cache()
+    estimate = skills.get_initial_context_estimate('claude-4.5-sonnet')
+    
+    # Should have all required fields
+    assert 'skill_count' in estimate
+    assert 'skill_tokens' in estimate
+    assert 'system_prompt_tokens' in estimate
+    assert 'total_initial_tokens' in estimate
+    assert 'used_percentage' in estimate
+    assert 'remaining_percentage' in estimate
+    assert 'context_window_size' in estimate
+    
+    # Context window should be 176k for Claude in Cursor
+    assert estimate['context_window_size'] == 176_000
+    
+    # Percentages should add to 100
+    assert round(estimate['used_percentage'] + estimate['remaining_percentage'], 1) == 100.0
+
+
+def test_get_initial_context_estimate_different_models():
+    """Test initial estimate with different model context windows."""
+    skills.clear_cache()
+    
+    claude_estimate = skills.get_initial_context_estimate('claude-4.5-sonnet')
+    gpt_estimate = skills.get_initial_context_estimate('gpt-4o')
+    
+    # Same skill count
+    assert claude_estimate['skill_count'] == gpt_estimate['skill_count']
+    
+    # Different context windows (Claude in Cursor uses 176k)
+    assert claude_estimate['context_window_size'] == 176_000
+    assert gpt_estimate['context_window_size'] == 128_000
+    
+    # GPT should have higher percentage (smaller window)
+    assert gpt_estimate['used_percentage'] > claude_estimate['used_percentage']
+
+
+def test_get_skills_summary():
+    """Test skills summary string generation."""
+    skills.clear_cache()
+    summary = skills.get_skills_summary()
+    
+    assert isinstance(summary, str)
+    assert 'skills' in summary.lower()
+    assert 'tokens' in summary.lower()
+
+
+def test_clear_cache():
+    """Test cache clearing."""
+    skills.clear_cache()
+    
+    # Get initial values
+    count1, tokens1 = skills.estimate_skill_tokens()
+    
+    # Clear and get again (should recompute, same values)
+    skills.clear_cache()
+    count2, tokens2 = skills.estimate_skill_tokens()
+    
+    assert count1 == count2
+    assert tokens1 == tokens2
+
+
+def run_tests():
+    """Run all tests without pytest."""
+    import traceback
+    
+    tests = [
+        test_find_skill_files,
+        test_estimate_skill_tokens,
+        test_estimate_skill_tokens_caching,
+        test_get_initial_context_estimate,
+        test_get_initial_context_estimate_different_models,
+        test_get_skills_summary,
+        test_clear_cache,
+    ]
+    
+    passed = 0
+    failed = 0
+    
+    print("=" * 60)
+    print("Running Skills Detection Tests")
+    print("=" * 60)
+    
+    for test in tests:
+        try:
+            test()
+            print(f"  ✓ {test.__name__}")
+            passed += 1
+        except AssertionError as e:
+            print(f"  ✗ {test.__name__}: {e}")
+            failed += 1
+        except Exception as e:
+            print(f"  ✗ {test.__name__}: {type(e).__name__}: {e}")
+            traceback.print_exc()
+            failed += 1
+    
+    print(f"\nResults: {passed}/{passed + failed} passed, {failed} failed")
+    return failed == 0
+
+
+if __name__ == '__main__':
+    success = run_tests()
+    sys.exit(0 if success else 1)

package/hooks/adapters/test_tokenizer.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""
+test_tokenizer.py - Unit tests for tokenizer module
+
+Run with:
+  python3 hooks/adapters/test_tokenizer.py
+"""
+import sys
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from adapters import tokenizer
+
+
+def test_estimate_tokens_empty_string():
+    """Test that empty string returns 0 tokens."""
+    assert tokenizer.estimate_tokens('') == 0
+    assert tokenizer.estimate_tokens(None) == 0
+
+
+def test_estimate_tokens_basic():
+    """Test basic token estimation."""
+    # A simple sentence should return some tokens
+    text = "Hello, this is a test."
+    tokens = tokenizer.estimate_tokens(text)
+    assert tokens > 0
+    assert tokens < 100  # Should be reasonable
+
+
+def test_estimate_tokens_longer_text():
+    """Test that longer text produces more tokens."""
+    short_text = "Hello"
+    long_text = "Hello " * 100
+    
+    short_tokens = tokenizer.estimate_tokens(short_text)
+    long_tokens = tokenizer.estimate_tokens(long_text)
+    
+    assert long_tokens > short_tokens
+
+
+def test_get_context_window_claude():
+    """Test context window lookup for Claude models (Cursor uses 176k)."""
+    assert tokenizer.get_context_window('claude-4.5-sonnet') == 176_000
+    assert tokenizer.get_context_window('claude-3-opus') == 176_000
+    assert tokenizer.get_context_window('claude-3.5-sonnet') == 176_000
+
+
+def test_get_context_window_gpt():
+    """Test context window lookup for GPT models."""
+    assert tokenizer.get_context_window('gpt-4o') == 128_000
+    assert tokenizer.get_context_window('gpt-4') == 8_192
+
+
+def test_get_context_window_gemini():
+    """Test context window lookup for Gemini models."""
+    assert tokenizer.get_context_window('gemini-2.5-pro') == 1_000_000
+    assert tokenizer.get_context_window('gemini-1.5-pro') == 2_000_000
+
+
+def test_get_context_window_unknown():
+    """Test context window lookup for unknown models uses default (176k for Cursor)."""
+    assert tokenizer.get_context_window('unknown-model') == 176_000
+    assert tokenizer.get_context_window('') == 176_000
+    assert tokenizer.get_context_window(None) == 176_000
+
+
+def test_get_context_window_partial_match():
+    """Test context window lookup with partial model names."""
+    # Should match based on partial string
+    assert tokenizer.get_context_window('my-claude-4.5-sonnet-tuned') == 176_000
+    assert tokenizer.get_context_window('fine-tuned-gpt-4o') == 128_000
+
+
+def test_calculate_context_percentage():
+    """Test context percentage calculation."""
+    assert tokenizer.calculate_context_percentage(50_000, 200_000) == 25.0
+    assert tokenizer.calculate_context_percentage(100_000, 200_000) == 50.0
+    assert tokenizer.calculate_context_percentage(200_000, 200_000) == 100.0
+
+
+def test_calculate_context_percentage_over_100():
+    """Test that percentage is capped at 100%."""
+    assert tokenizer.calculate_context_percentage(250_000, 200_000) == 100.0
+
+
+def test_calculate_context_percentage_zero_window():
+    """Test that zero window returns 0%."""
+    assert tokenizer.calculate_context_percentage(50_000, 0) == 0.0
+
+
+def test_calculate_context_metrics():
+    """Test full context metrics calculation."""
+    metrics = tokenizer.calculate_context_metrics(44_000, 'claude-4.5-sonnet')
+    
+    # 44,000 / 176,000 = 25%
+    assert metrics['used_percentage'] == 25.0
+    assert metrics['remaining_percentage'] == 75.0
+    assert metrics['context_window_size'] == 176_000
+    assert metrics['estimated_tokens'] == 44_000
+
+
+def test_calculate_context_metrics_different_model():
+    """Test context metrics with different model."""
+    metrics = tokenizer.calculate_context_metrics(64_000, 'gpt-4o')
+    
+    assert metrics['used_percentage'] == 50.0
+    assert metrics['context_window_size'] == 128_000
+
+
+def run_tests():
+    """Run all tests without pytest."""
+    import traceback
+    
+    tests = [
+        test_estimate_tokens_empty_string,
+        test_estimate_tokens_basic,
+        test_estimate_tokens_longer_text,
+        test_get_context_window_claude,
+        test_get_context_window_gpt,
+        test_get_context_window_gemini,
+        test_get_context_window_unknown,
+        test_get_context_window_partial_match,
+        test_calculate_context_percentage,
+        test_calculate_context_percentage_over_100,
+        test_calculate_context_percentage_zero_window,
+        test_calculate_context_metrics,
+        test_calculate_context_metrics_different_model,
+    ]
+    
+    passed = 0
+    failed = 0
+    
+    print("=" * 60)
+    print("Running Tokenizer Tests")
+    print("=" * 60)
+    
+    for test in tests:
+        try:
+            test()
+            print(f"  ✓ {test.__name__}")
+            passed += 1
+        except AssertionError as e:
+            print(f"  ✗ {test.__name__}: {e}")
+            failed += 1
+        except Exception as e:
+            print(f"  ✗ {test.__name__}: {type(e).__name__}: {e}")
+            traceback.print_exc()
+            failed += 1
+    
+    print(f"\nResults: {passed}/{passed + failed} passed, {failed} failed")
+    return failed == 0
+
+
+if __name__ == '__main__':
+    success = run_tests()
+    sys.exit(0 if success else 1)