quantwise 1.2.0 → 1.2.2

package/.claude/skills/market-top-detector/scripts/tests/test_distribution_day.py

@@ -0,0 +1,92 @@
+"""Tests for Distribution Day Calculator"""
+
+from calculators.distribution_day_calculator import (
+    _count_distribution_days,
+    _score_distribution_days,
+    calculate_distribution_days,
+)
+from helpers import make_history, make_history_with_volumes
+
+
+class TestScoreDistributionDays:
+    """Boundary tests for scoring thresholds."""
+
+    def test_zero_days(self):
+        assert _score_distribution_days(0) == 0
+
+    def test_one_day(self):
+        assert _score_distribution_days(1) == 15
+
+    def test_two_days(self):
+        assert _score_distribution_days(2) == 30
+
+    def test_three_days(self):
+        assert _score_distribution_days(3) == 55
+
+    def test_four_days_oneil_threshold(self):
+        assert _score_distribution_days(4) == 75
+
+    def test_five_days(self):
+        assert _score_distribution_days(5) == 90
+
+    def test_six_plus_days(self):
+        assert _score_distribution_days(6) == 100
+        assert _score_distribution_days(8) == 100
+
+    def test_fractional_stalling(self):
+        """Stalling days count as 0.5"""
+        assert _score_distribution_days(3.5) == 55  # 3.5 >= 3
+        assert _score_distribution_days(4.5) == 75  # 4.5 >= 4
+
+
+class TestCountDistributionDays:
+    """Tests for distribution day detection logic."""
+
+    def test_empty_history(self):
+        result = _count_distribution_days([], "TEST")
+        assert result["distribution_days"] == 0
+
+    def test_single_day(self):
+        result = _count_distribution_days([{"close": 100, "volume": 1000}], "TEST")
+        assert result["distribution_days"] == 0
+
+    def test_distribution_day_detected(self):
+        """Price drop >= 0.2% on higher volume = distribution day."""
+        history = make_history_with_volumes(
+            [
+                (99.0, 1200000),  # Today: -1% drop, higher volume → distribution
+                (100.0, 1000000),  # Yesterday
+                (100.5, 800000),  # Two days ago: lower volume than yesterday
+            ]
+        )
+        result = _count_distribution_days(history, "TEST")
+        assert result["distribution_days"] >= 1
+
+    def test_stalling_day_detected(self):
+        """Volume increases but price gain < 0.1% = stalling day."""
+        history = make_history_with_volumes(
+            [
+                (100.05, 1200000),  # Today: +0.05%, higher volume
+                (100.0, 1000000),  # Yesterday
+                (99.5, 900000),  # Two days ago
+            ]
+        )
+        result = _count_distribution_days(history, "TEST")
+        assert result["stalling_days"] >= 1
+
+
+class TestCalculateDistributionDays:
+    """Integration tests."""
+
+    def test_uses_higher_count(self):
+        """Should use the worse of S&P 500 / NASDAQ."""
+        # Create histories where NASDAQ has more distribution days
+        sp_history = make_history([100] * 30)
+        # NASDAQ with distribution pattern
+        nasdaq_cv = [(99.0 - i * 0.3, 1200000 + i * 10000) for i in range(15)]
+        nasdaq_cv += [(100.0 + i * 0.1, 1000000) for i in range(15)]
+        nasdaq_history = make_history_with_volumes(nasdaq_cv)
+
+        result = calculate_distribution_days(sp_history, nasdaq_history)
+        assert "score" in result
+        assert "effective_count" in result

package/.claude/skills/market-top-detector/scripts/tests/test_index_technical.py

@@ -0,0 +1,73 @@
+"""Tests for Index Technical Calculator"""
+
+from calculators.index_technical_calculator import (
+    _evaluate_index,
+    calculate_index_technical,
+)
+from helpers import make_history
+
+
+class TestEvaluateIndex:
+    """Test single index evaluation."""
+
+    def test_insufficient_data(self):
+        """Less than 21 days → data_available=False."""
+        result = _evaluate_index("TEST", [{"close": 100}] * 10)
+        assert result["data_available"] is False
+        assert result["raw_score"] == 0
+
+    def test_sufficient_data(self):
+        """21+ days → data_available=True."""
+        history = make_history([100 - i * 0.1 for i in range(50)])
+        result = _evaluate_index("TEST", history)
+        assert result["data_available"] is True
+
+    def test_below_21ema_adds_8(self):
+        """Price significantly below 21 EMA should trigger flag."""
+        # Create downtrend: recent prices well below earlier ones
+        closes = [90] * 5 + [100 + i * 0.5 for i in range(45)]
+        history = make_history(closes)
+        result = _evaluate_index("TEST", history)
+        assert any("21 EMA" in f for f in result["flags"])
+
+
+class TestCalculateIndexTechnical:
+    """Test composite index technical score."""
+
+    def test_both_available(self):
+        """Both S&P and NASDAQ have data → average them."""
+        sp = make_history([100 - i * 0.1 for i in range(50)])
+        nq = make_history([200 - i * 0.2 for i in range(50)])
+        result = calculate_index_technical(sp, nq)
+        assert result["data_available"] is True
+        assert result["sp500"]["data_available"] is True
+        assert result["nasdaq"]["data_available"] is True
+
+    def test_nasdaq_missing_uses_sp_only(self):
+        """NASDAQ insufficient data → use S&P 500 only, no halving."""
+        sp = make_history([100 - i * 0.1 for i in range(50)])
+        nq_short = [{"close": 200}] * 5  # Too short
+
+        calculate_index_technical(sp, sp)  # Both = S&P (warm up)
+        result_sp_only = calculate_index_technical(sp, nq_short)
+
+        # S&P-only score should equal S&P's raw_score (not halved)
+        sp_raw = result_sp_only["sp500"]["raw_score"]
+        assert result_sp_only["score"] == round(min(100, max(0, sp_raw)))
+        assert result_sp_only["nasdaq"]["data_available"] is False
+
+    def test_both_missing_returns_50(self):
+        """Both insufficient → score=50, data_available=False."""
+        short = [{"close": 100}] * 5
+        result = calculate_index_technical(short, short)
+        assert result["score"] == 50
+        assert result["data_available"] is False
+        assert "NO DATA" in result["signal"]
+
+    def test_sp_missing_nasdaq_available(self):
+        """S&P insufficient, NASDAQ available → use NASDAQ only."""
+        sp_short = [{"close": 100}] * 5
+        nq = make_history([200 - i * 0.2 for i in range(50)])
+        result = calculate_index_technical(sp_short, nq)
+        nq_raw = result["nasdaq"]["raw_score"]
+        assert result["score"] == round(min(100, max(0, nq_raw)))

package/.claude/skills/market-top-detector/scripts/tests/test_leading_stock.py

@@ -0,0 +1,57 @@
+"""Tests for Leading Stock Calculator"""
+
+from calculators.leading_stock_calculator import (
+    _evaluate_etf,
+    calculate_leading_stock_health,
+)
+
+
+class TestEvaluateETF:
+    """Test individual ETF evaluation."""
+
+    def test_near_highs_healthy(self):
+        quote = {"price": 100, "yearHigh": 102, "yearLow": 80}
+        history = [{"close": 100 - i * 0.1, "volume": 1000000} for i in range(60)]
+        result = _evaluate_etf("TEST", quote, history)
+        assert result["deterioration_score"] <= 20
+
+    def test_deep_correction(self):
+        quote = {"price": 70, "yearHigh": 100, "yearLow": 65}
+        history = [{"close": 70 + i * 0.3, "volume": 1000000} for i in range(60)]
+        result = _evaluate_etf("TEST", quote, history)
+        assert result["deterioration_score"] >= 30
+
+
+class TestCalculateLeadingStockHealth:
+    """Test composite leading stock calculation."""
+
+    def test_no_data_returns_50(self):
+        """No quotes → score 50 (neutral), data_available=False."""
+        result = calculate_leading_stock_health({}, {})
+        assert result["score"] == 50
+        assert result["etfs_evaluated"] == 0
+        assert result["data_available"] is False
+
+    def test_healthy_leaders(self):
+        quotes = {}
+        historical = {}
+        for sym in ["ARKK", "WCLD", "IGV"]:
+            quotes[sym] = {"price": 100, "yearHigh": 102, "yearLow": 80}
+            historical[sym] = [{"close": 100 - i * 0.05, "volume": 1000000} for i in range(60)]
+        result = calculate_leading_stock_health(quotes, historical)
+        assert result["score"] <= 30  # Healthy
+        assert result["data_available"] is True
+
+    def test_amplification_at_60pct(self):
+        """60%+ ETFs deteriorating triggers 1.3x amplification."""
+        quotes = {}
+        historical = {}
+        # All ETFs in deep correction: -30% from high, below 50DMA
+        for sym in ["ARKK", "WCLD", "IGV", "XBI", "SOXX", "SMH", "KWEB", "TAN"]:
+            quotes[sym] = {"price": 70, "yearHigh": 100, "yearLow": 60}
+            # Create declining history so price is well below MAs
+            historical[sym] = [
+                {"close": 70 + i * 0.5, "high": 72 + i * 0.5, "volume": 1000000} for i in range(60)
+            ]
+        result = calculate_leading_stock_health(quotes, historical)
+        assert result["amplified"] is True

package/.claude/skills/market-top-detector/scripts/tests/test_scorer.py

@@ -0,0 +1,180 @@
+"""Tests for Composite Scorer and FTD Detection"""
+
+from scorer import (
+    COMPONENT_WEIGHTS,
+    calculate_composite_score,
+    detect_follow_through_day,
+)
+
+
+class TestCompositeScore:
+    """Test composite scoring."""
+
+    def test_all_zeros(self):
+        scores = {k: 0 for k in COMPONENT_WEIGHTS}
+        result = calculate_composite_score(scores)
+        assert result["composite_score"] == 0
+        assert "Green" in result["zone"]
+
+    def test_all_100(self):
+        scores = {k: 100 for k in COMPONENT_WEIGHTS}
+        result = calculate_composite_score(scores)
+        assert result["composite_score"] == 100.0
+        assert "Critical" in result["zone"]
+
+    def test_moderate_risk(self):
+        """Calibration target: ~48-50 for moderate risk."""
+        scores = {
+            "distribution_days": 45,
+            "leading_stocks": 52,
+            "defensive_rotation": 82,
+            "breadth_divergence": 20,
+            "index_technical": 42,
+            "sentiment": 62,
+        }
+        result = calculate_composite_score(scores)
+        assert 40 <= result["composite_score"] <= 55
+
+    def test_weights_sum_to_1(self):
+        total = sum(COMPONENT_WEIGHTS.values())
+        assert abs(total - 1.0) < 0.001
+
+    def test_strongest_weakest(self):
+        scores = {
+            "distribution_days": 90,
+            "leading_stocks": 10,
+            "defensive_rotation": 50,
+            "breadth_divergence": 50,
+            "index_technical": 50,
+            "sentiment": 50,
+        }
+        result = calculate_composite_score(scores)
+        assert result["strongest_warning"]["component"] == "distribution_days"
+        assert result["weakest_warning"]["component"] == "leading_stocks"
+
+
+class TestDataQuality:
+    """Test data quality tracking."""
+
+    def test_all_available(self):
+        scores = {k: 50 for k in COMPONENT_WEIGHTS}
+        avail = {k: True for k in COMPONENT_WEIGHTS}
+        result = calculate_composite_score(scores, avail)
+        dq = result["data_quality"]
+        assert dq["available_count"] == 6
+        assert "Complete" in dq["label"]
+        assert dq["missing_components"] == []
+
+    def test_some_missing(self):
+        scores = {k: 50 for k in COMPONENT_WEIGHTS}
+        avail = {k: True for k in COMPONENT_WEIGHTS}
+        avail["breadth_divergence"] = False
+        avail["sentiment"] = False
+        result = calculate_composite_score(scores, avail)
+        dq = result["data_quality"]
+        assert dq["available_count"] == 4
+        assert "Partial" in dq["label"]
+        assert len(dq["missing_components"]) == 2
+
+    def test_many_missing(self):
+        scores = {k: 50 for k in COMPONENT_WEIGHTS}
+        avail = {k: False for k in COMPONENT_WEIGHTS}
+        avail["distribution_days"] = True
+        avail["leading_stocks"] = True
+        result = calculate_composite_score(scores, avail)
+        dq = result["data_quality"]
+        assert dq["available_count"] == 2
+        assert "Limited" in dq["label"]
+
+    def test_backward_compat_no_availability(self):
+        """Without data_availability, all assumed available."""
+        scores = {k: 50 for k in COMPONENT_WEIGHTS}
+        result = calculate_composite_score(scores)
+        dq = result["data_quality"]
+        assert dq["available_count"] == 6
+        assert "Complete" in dq["label"]
+
+
+class TestFollowThroughDay:
+    """Test O'Neil-strict FTD detection."""
+
+    def test_not_applicable_below_40(self):
+        result = detect_follow_through_day([], 30.0)
+        assert result["applicable"] is False
+
+    def test_insufficient_data(self):
+        result = detect_follow_through_day([{"close": 100}] * 5, 50.0)
+        assert result["ftd_detected"] is False
+
+    def test_no_swing_low(self):
+        """Flat market → no swing low found."""
+        history = [{"close": 100, "volume": 1000000, "date": f"day-{i}"} for i in range(30)]
+        result = detect_follow_through_day(history, 50.0)
+        assert result["ftd_detected"] is False
+
+    def test_ftd_detected_on_clear_pattern(self):
+        """
+        Create a clear pattern:
+        - Days 0-9: prices rise from 100 to 109 (establishing high)
+        - Days 10-14: decline from 109 to 100 (5+ down days, ~8% drop)
+        - Day 15: swing low at 100
+        - Day 16: rally day 1 (up from 100 to 101)
+        - Day 17-18: rally continues (101.5, 102)
+        - Day 19 (rally day 4): FTD - big gain +2% on higher volume
+
+        History is most-recent-first, so reversed.
+        """
+        bars = []
+        # Build chronologically, then reverse
+        # Days 0-9: uptrend
+        for i in range(10):
+            bars.append({"close": 100 + i, "volume": 1000000, "date": f"2026-01-{i + 1:02d}"})
+
+        # Days 10-14: decline (5 down days from 109)
+        decline_prices = [107, 105, 103, 101, 100]
+        for i, p in enumerate(decline_prices):
+            bars.append({"close": p, "volume": 1100000, "date": f"2026-01-{11 + i:02d}"})
+
+        # Day 15: swing low
+        bars.append({"close": 99.5, "volume": 1200000, "date": "2026-01-16"})
+
+        # Day 16: rally day 1
+        bars.append({"close": 101, "volume": 1000000, "date": "2026-01-17"})
+
+        # Day 17-18: rally continues
+        bars.append({"close": 101.5, "volume": 1000000, "date": "2026-01-18"})
+        bars.append({"close": 102, "volume": 1000000, "date": "2026-01-19"})
+
+        # Day 19: FTD - +2% gain on higher volume
+        bars.append({"close": 104.04, "volume": 1500000, "date": "2026-01-20"})
+
+        # Reverse to most-recent-first
+        history = list(reversed(bars))
+
+        result = detect_follow_through_day(history, 55.0)
+        assert result["ftd_detected"] is True
+        assert result["rally_day_count"] >= 4
+
+    def test_rally_reset_below_swing_low(self):
+        """Rally resets if price drops below swing low."""
+        bars = []
+        # Uptrend
+        for i in range(10):
+            bars.append({"close": 100 + i, "volume": 1000000, "date": f"d-{i}"})
+        # Decline
+        for i, p in enumerate([107, 105, 103, 101, 100]):
+            bars.append({"close": p, "volume": 1100000, "date": f"d-{10 + i}"})
+        # Swing low
+        bars.append({"close": 99, "volume": 1200000, "date": "d-15"})
+        # Brief rally
+        bars.append({"close": 100, "volume": 1000000, "date": "d-16"})
+        # Drop below swing low → reset
+        bars.append({"close": 98, "volume": 1000000, "date": "d-17"})
+        # New rally from lower base
+        bars.append({"close": 99, "volume": 1000000, "date": "d-18"})
+        bars.append({"close": 99.5, "volume": 1000000, "date": "d-19"})
+
+        history = list(reversed(bars))
+        result = detect_follow_through_day(history, 55.0)
+        # FTD should NOT be detected (rally reset, new rally too short)
+        assert result["ftd_detected"] is False

package/.claude/skills/market-top-detector/scripts/tests/test_sentiment.py

@@ -0,0 +1,64 @@
+"""Tests for Sentiment Calculator"""
+
+from calculators.sentiment_calculator import calculate_sentiment
+
+
+class TestSentimentMissingData:
+    """Test missing data handling."""
+
+    def test_all_none_returns_50(self):
+        """All inputs None → score=50, data_available=False."""
+        result = calculate_sentiment()
+        assert result["score"] == 50
+        assert result["data_available"] is False
+        assert "NO DATA" in result["signal"]
+
+    def test_partial_data_is_available(self):
+        """At least one input → data_available=True."""
+        result = calculate_sentiment(vix_level=15.0)
+        assert result["data_available"] is True
+
+    def test_vix_only(self):
+        result = calculate_sentiment(vix_level=15.0)
+        assert result["score"] == 10  # VIX 15 → +10pt
+
+    def test_put_call_only(self):
+        result = calculate_sentiment(put_call_ratio=0.65)
+        assert result["score"] == 30  # PC < 0.70 → +30pt
+
+
+class TestSentimentScoring:
+    """Boundary tests for sentiment scoring."""
+
+    def test_extreme_complacency(self):
+        """Low VIX + low P/C + steep contango = max score."""
+        result = calculate_sentiment(
+            vix_level=11.0,
+            put_call_ratio=0.55,
+            vix_term_structure="steep_contango",
+        )
+        assert result["score"] == 100  # 30+40+30=100
+
+    def test_high_fear(self):
+        """High VIX + high P/C + backwardation = 0 or negative."""
+        result = calculate_sentiment(
+            vix_level=30.0,
+            put_call_ratio=0.95,
+            vix_term_structure="backwardation",
+        )
+        assert result["score"] == 0  # -10+0+(-10) = -20 → clamped to 0
+
+    def test_moderate_sentiment(self):
+        result = calculate_sentiment(
+            vix_level=15.0,
+            put_call_ratio=0.75,
+            vix_term_structure="contango",
+        )
+        # VIX 15→10, PC 0.75→15, contango→15 = 40
+        assert result["score"] == 40
+
+    def test_margin_debt_not_scored(self):
+        """Margin debt is context only, should not affect score."""
+        without = calculate_sentiment(vix_level=15.0)
+        with_margin = calculate_sentiment(vix_level=15.0, margin_debt_yoy_pct=40.0)
+        assert without["score"] == with_margin["score"]