quantwise 1.2.0 → 1.2.2

package/.claude/skills/market-top-detector/scripts/calculators/distribution_day_calculator.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+"""
+Component 1: Distribution Day Count (Weight: 25%)
+
+O'Neil's Distribution Day Rules:
+- Distribution Day: Index drops >= 0.2% on higher volume than previous day
+- Stalling Day: Volume increases but price gain < 0.1% (half weight)
+- Days expire after 25 trading days
+- Count the higher of S&P 500 or NASDAQ
+
+Scoring:
+  6+ distribution days -> 100 (Critical)
+  5 days -> 90
+  4 days -> 75  (O'Neil's warning threshold)
+  3 days -> 55
+  2 days -> 30
+  1 day  -> 15
+  0 days -> 0
+"""
+
+from typing import Dict, List, Optional
+
+
+def calculate_distribution_days(sp500_history: List[Dict],
+                                nasdaq_history: List[Dict]) -> Dict:
+    """
+    Calculate distribution day count for S&P 500 and NASDAQ.
+
+    Args:
+        sp500_history: List of daily OHLCV dicts (most recent first), at least 30 days
+        nasdaq_history: List of daily OHLCV dicts (most recent first), at least 30 days
+
+    Returns:
+        Dict with score (0-100), distribution_days, stalling_days, details
+    """
+    sp500_result = _count_distribution_days(sp500_history, "S&P 500")
+    nasdaq_result = _count_distribution_days(nasdaq_history, "NASDAQ")
+
+    # Use the higher (worse) effective count
+    sp500_effective = sp500_result["distribution_days"] + 0.5 * sp500_result["stalling_days"]
+    nasdaq_effective = nasdaq_result["distribution_days"] + 0.5 * nasdaq_result["stalling_days"]
+
+    if sp500_effective >= nasdaq_effective:
+        primary = sp500_result
+        primary_name = "S&P 500"
+        secondary = nasdaq_result
+        secondary_name = "NASDAQ"
+    else:
+        primary = nasdaq_result
+        primary_name = "NASDAQ"
+        secondary = sp500_result
+        secondary_name = "S&P 500"
+
+    effective_count = max(sp500_effective, nasdaq_effective)
+    score = _score_distribution_days(effective_count)
+
+    # Build signal description
+    if effective_count >= 5:
+        signal = "CRITICAL: Heavy distribution detected"
+    elif effective_count >= 4:
+        signal = "WARNING: O'Neil's threshold reached"
+    elif effective_count >= 3:
+        signal = "CAUTION: Moderate distribution"
+    elif effective_count >= 1:
+        signal = "MINOR: Some distribution present"
+    else:
+        signal = "CLEAR: No distribution"
+
+    return {
+        "score": score,
+        "effective_count": effective_count,
+        "signal": signal,
+        "primary_index": primary_name,
+        "sp500": {
+            "distribution_days": sp500_result["distribution_days"],
+            "stalling_days": sp500_result["stalling_days"],
+            "effective_count": sp500_effective,
+            "details": sp500_result["details"],
+        },
+        "nasdaq": {
+            "distribution_days": nasdaq_result["distribution_days"],
+            "stalling_days": nasdaq_result["stalling_days"],
+            "effective_count": nasdaq_effective,
+            "details": nasdaq_result["details"],
+        },
+    }
+
+
+def _count_distribution_days(history: List[Dict], index_name: str) -> Dict:
+    """Count distribution and stalling days in the last 25 trading days"""
+    if not history or len(history) < 2:
+        return {"distribution_days": 0, "stalling_days": 0, "details": []}
+
+    # We need at least 26 days to check 25 days of change
+    # history[0] = most recent, history[1] = day before, etc.
+    window = min(25, len(history) - 1)  # 25 trading day window
+
+    distribution_days = 0
+    stalling_days = 0
+    details = []
+
+    for i in range(window):
+        today = history[i]
+        yesterday = history[i + 1]
+
+        today_close = today.get("close", today.get("adjClose", 0))
+        yesterday_close = yesterday.get("close", yesterday.get("adjClose", 0))
+        today_volume = today.get("volume", 0)
+        yesterday_volume = yesterday.get("volume", 0)
+
+        if yesterday_close == 0 or yesterday_volume == 0:
+            continue
+
+        pct_change = (today_close - yesterday_close) / yesterday_close * 100
+        volume_increase = today_volume > yesterday_volume
+
+        date = today.get("date", f"day-{i}")
+
+        # Distribution day: price drops >= 0.2% AND volume increases
+        if pct_change <= -0.2 and volume_increase:
+            distribution_days += 1
+            details.append({
+                "date": date,
+                "type": "distribution",
+                "pct_change": round(pct_change, 2),
+                "volume_change": round((today_volume / yesterday_volume - 1) * 100, 1),
+            })
+
+        # Stalling day: volume increases but price gain < 0.1%
+        elif volume_increase and 0 <= pct_change < 0.1:
+            stalling_days += 1
+            details.append({
+                "date": date,
+                "type": "stalling",
+                "pct_change": round(pct_change, 2),
+                "volume_change": round((today_volume / yesterday_volume - 1) * 100, 1),
+            })
+
+    return {
+        "distribution_days": distribution_days,
+        "stalling_days": stalling_days,
+        "details": details,
+    }
+
+
+def _score_distribution_days(effective_count: float) -> int:
+    """Convert effective distribution day count to 0-100 score"""
+    if effective_count >= 6:
+        return 100
+    elif effective_count >= 5:
+        return 90
+    elif effective_count >= 4:
+        return 75
+    elif effective_count >= 3:
+        return 55
+    elif effective_count >= 2:
+        return 30
+    elif effective_count >= 1:
+        return 15
+    else:
+        return 0

package/.claude/skills/market-top-detector/scripts/calculators/index_technical_calculator.py

@@ -0,0 +1,254 @@
+#!/usr/bin/env python3
+"""
+Component 5: Index Technical Condition (Weight: 15%)
+
+Evaluates technical health of S&P 500 and NASDAQ.
+Uses shared historical data from Component 1 (no additional API calls).
+
+Checkpoints (per index, S&P 500 + NASDAQ):
+1. Price < 21 EMA (short-term weakness)        -> +8pt
+2. Price < 50 EMA (medium-term breakdown)       -> +12pt
+3. 21 EMA < 50 EMA (MA bearish crossover)       -> +10pt
+4. Price < 200 SMA (long-term trend breakdown)   -> +15pt
+5. Failed rally pattern                          -> +10pt
+6. Lower highs pattern                           -> +10pt
+7. Gap down on volume                            -> +10pt
+
+Max per index: ~75 points (not all conditions fire at once in early stages)
+Final: average of both indices, scaled to 0-100
+"""
+
+from typing import Dict, List, Optional
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+from fmp_client import FMPClient
+
+
+def calculate_index_technical(sp500_history: List[Dict],
+                              nasdaq_history: List[Dict],
+                              sp500_quote: Optional[Dict] = None,
+                              nasdaq_quote: Optional[Dict] = None) -> Dict:
+    """
+    Calculate index technical condition score.
+
+    Args:
+        sp500_history: S&P 500 daily OHLCV (most recent first, 250+ days preferred)
+        nasdaq_history: NASDAQ daily OHLCV (most recent first, 250+ days preferred)
+        sp500_quote: Current S&P 500 quote (optional, for real-time price)
+        nasdaq_quote: Current NASDAQ/QQQ quote (optional)
+
+    Returns:
+        Dict with score (0-100), sp500_details, nasdaq_details, signal
+    """
+    sp500_result = _evaluate_index("S&P 500", sp500_history, sp500_quote)
+    nasdaq_result = _evaluate_index("NASDAQ", nasdaq_history, nasdaq_quote)
+
+    # Average only indices with available data
+    scores = []
+    if sp500_result.get("data_available", False):
+        scores.append(sp500_result["raw_score"])
+    if nasdaq_result.get("data_available", False):
+        scores.append(nasdaq_result["raw_score"])
+
+    if not scores:
+        final_score = 50  # Neutral when no data
+        signal = "NO DATA: Index data unavailable"
+        return {
+            "score": final_score,
+            "signal": signal,
+            "sp500": sp500_result,
+            "nasdaq": nasdaq_result,
+            "data_available": False,
+        }
+
+    avg_score = sum(scores) / len(scores)
+    final_score = round(min(100, max(0, avg_score)))
+
+    if final_score >= 70:
+        signal = "CRITICAL: Major technical breakdown"
+    elif final_score >= 50:
+        signal = "WARNING: Significant technical deterioration"
+    elif final_score >= 35:
+        signal = "CAUTION: Short-term weakness detected"
+    elif final_score >= 15:
+        signal = "MIXED: Minor technical concerns"
+    else:
+        signal = "HEALTHY: Technical structure intact"
+
+    return {
+        "score": final_score,
+        "signal": signal,
+        "sp500": sp500_result,
+        "nasdaq": nasdaq_result,
+        "data_available": True,
+    }
+
+
+def _evaluate_index(name: str, history: List[Dict],
+                    quote: Optional[Dict] = None) -> Dict:
+    """Evaluate a single index's technical condition"""
+    if not history or len(history) < 21:
+        return {"raw_score": 0, "flags": ["Insufficient data"], "mas": {},
+                "data_available": False}
+
+    closes = [d.get("close", d.get("adjClose", 0)) for d in history]
+    highs = [d.get("high", d.get("close", 0)) for d in history]
+    lows = [d.get("low", d.get("close", 0)) for d in history]
+    volumes = [d.get("volume", 0) for d in history]
+
+    # Current price (from quote or most recent close)
+    if quote:
+        price = quote.get("price", closes[0])
+    else:
+        price = closes[0]
+
+    score = 0
+    flags = []
+    mas = {}
+
+    # Calculate moving averages
+    ema21 = _calc_ema(closes, 21)
+    mas["ema21"] = round(ema21, 2)
+
+    if len(closes) >= 50:
+        ema50 = _calc_ema(closes, 50)
+        mas["ema50"] = round(ema50, 2)
+    else:
+        ema50 = None
+
+    if len(closes) >= 200:
+        sma200 = sum(closes[:200]) / 200
+        mas["sma200"] = round(sma200, 2)
+    else:
+        sma200 = None
+
+    # Check 1: Price < 21 EMA (short-term weakness)
+    if price < ema21:
+        score += 8
+        pct_below = (price - ema21) / ema21 * 100
+        flags.append(f"Below 21 EMA ({pct_below:+.1f}%)")
+
+    # Check 2: Price < 50 EMA (medium-term breakdown)
+    if ema50 and price < ema50:
+        score += 12
+        pct_below = (price - ema50) / ema50 * 100
+        flags.append(f"Below 50 EMA ({pct_below:+.1f}%)")
+
+    # Check 3: 21 EMA < 50 EMA (bearish crossover)
+    if ema50 and ema21 < ema50:
+        score += 10
+        flags.append("21 EMA < 50 EMA (bearish crossover)")
+
+    # Check 4: Price < 200 SMA (long-term trend breakdown)
+    if sma200 and price < sma200:
+        score += 15
+        pct_below = (price - sma200) / sma200 * 100
+        flags.append(f"Below 200 SMA ({pct_below:+.1f}%)")
+
+    # Check 5: Failed rally pattern
+    if _detect_failed_rally(closes, volumes):
+        score += 10
+        flags.append("Failed rally pattern detected")
+
+    # Check 6: Lower highs pattern (20 day)
+    if _detect_lower_highs(highs, lookback=20):
+        score += 10
+        flags.append("Lower highs pattern (20 day)")
+
+    # Check 7: Gap down on volume
+    if _detect_gap_down(history):
+        score += 10
+        flags.append("Recent gap down on volume")
+
+    return {
+        "raw_score": min(100, score),
+        "price": round(price, 2),
+        "flags": flags,
+        "mas": mas,
+        "data_available": True,
+    }
+
+
+def _calc_ema(prices: List[float], period: int) -> float:
+    """Calculate EMA from prices (most recent first)"""
+    if len(prices) < period:
+        return sum(prices) / len(prices)
+
+    prices_rev = prices[::-1]
+    sma = sum(prices_rev[:period]) / period
+    ema = sma
+    k = 2 / (period + 1)
+    for p in prices_rev[period:]:
+        ema = p * k + ema * (1 - k)
+    return ema
+
+
+def _detect_failed_rally(closes: List[float], volumes: List[int],
+                         lookback: int = 15) -> bool:
+    """
+    Detect failed rally: price bounces then fails to make new high
+    within recent lookback period.
+    """
+    if len(closes) < lookback:
+        return False
+
+    recent = closes[:lookback]
+    # Find the peak in recent data
+    peak_idx = recent.index(max(recent))
+
+    # Failed rally: peak occurred 3-10 days ago, current price is below that peak
+    if 3 <= peak_idx <= 10:
+        # Price fell from peak
+        drop = (recent[0] - recent[peak_idx]) / recent[peak_idx] * 100
+        if drop < -2.0:  # Dropped >2% from recent peak
+            return True
+    return False
+
+
+def _detect_lower_highs(highs: List[float], lookback: int = 20) -> bool:
+    """Detect lower highs pattern in price action"""
+    if len(highs) < lookback:
+        return False
+
+    recent_highs = highs[:lookback]
+
+    # Find swing highs (local maxima)
+    swing_highs = []
+    for i in range(1, len(recent_highs) - 1):
+        if recent_highs[i] > recent_highs[i-1] and recent_highs[i] > recent_highs[i+1]:
+            swing_highs.append(recent_highs[i])
+
+    if len(swing_highs) < 2:
+        return False
+
+    # Most recent swing high lower than previous
+    return swing_highs[0] < swing_highs[1]
+
+
+def _detect_gap_down(history: List[Dict], lookback: int = 5) -> bool:
+    """Detect gap down on increased volume in recent sessions"""
+    if len(history) < lookback + 1:
+        return False
+
+    for i in range(lookback):
+        today = history[i]
+        yesterday = history[i + 1]
+
+        today_open = today.get("open", 0)
+        yesterday_close = yesterday.get("close", yesterday.get("adjClose", 0))
+        today_volume = today.get("volume", 0)
+        yesterday_volume = yesterday.get("volume", 0)
+
+        if yesterday_close == 0 or yesterday_volume == 0:
+            continue
+
+        gap_pct = (today_open - yesterday_close) / yesterday_close * 100
+        volume_increase = today_volume > yesterday_volume * 1.1
+
+        # Gap down >= 0.5% on higher volume
+        if gap_pct <= -0.5 and volume_increase:
+            return True
+
+    return False

package/.claude/skills/market-top-detector/scripts/calculators/leading_stock_calculator.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+"""
+Component 2: Leading Stock Health (Weight: 20%)
+
+Evaluates health of leading/growth ETFs as proxy for market leadership.
+Uses ETF baskets instead of individual stocks for API efficiency.
+
+ETF Basket: ARKK, WCLD, IGV, XBI, SOXX, SMH, KWEB, TAN
+
+Evaluation per ETF:
+- Distance from 52-week high
+- Position vs 50DMA and 200DMA
+- Lower highs pattern detection
+
+Scoring: Weighted average of ETF deterioration signals.
+If 60%+ ETFs are deteriorating, apply 1.3x amplification.
+"""
+
+from typing import Dict, List, Optional
+import sys
+
+# Leading/Growth ETF basket
+LEADING_ETFS = ["ARKK", "WCLD", "IGV", "XBI", "SOXX", "SMH", "KWEB", "TAN"]
+
+
+def calculate_leading_stock_health(quotes: Dict[str, Dict],
+                                   historical: Dict[str, List[Dict]]) -> Dict:
+    """
+    Calculate leading stock health score.
+
+    Args:
+        quotes: Dict of symbol -> quote data (from FMP batch quote)
+        historical: Dict of symbol -> list of daily OHLCV (most recent first, ~60 days)
+
+    Returns:
+        Dict with score (0-100), etf_details, signal
+    """
+    etf_scores = []
+    etf_details = {}
+
+    for symbol in LEADING_ETFS:
+        quote = quotes.get(symbol)
+        hist = historical.get(symbol, [])
+
+        if not quote:
+            continue
+
+        detail = _evaluate_etf(symbol, quote, hist)
+        etf_scores.append(detail["deterioration_score"])
+        etf_details[symbol] = detail
+
+    if not etf_scores:
+        return {
+            "score": 50,
+            "signal": "INSUFFICIENT DATA",
+            "etf_details": {},
+            "etfs_evaluated": 0,
+            "etfs_deteriorating": 0,
+            "data_available": False,
+        }
+
+    avg_deterioration = sum(etf_scores) / len(etf_scores)
+
+    # Count deteriorating ETFs (score >= 50)
+    deteriorating_count = sum(1 for s in etf_scores if s >= 50)
+    deteriorating_pct = deteriorating_count / len(etf_scores)
+
+    # Amplification: if 60%+ ETFs deteriorating, multiply by 1.3
+    if deteriorating_pct >= 0.60:
+        final_score = min(100, avg_deterioration * 1.3)
+    else:
+        final_score = avg_deterioration
+
+    final_score = round(min(100, max(0, final_score)))
+
+    # Signal
+    if final_score >= 70:
+        signal = "CRITICAL: Leadership broadly deteriorating"
+    elif final_score >= 50:
+        signal = "WARNING: Multiple leaders weakening"
+    elif final_score >= 30:
+        signal = "CAUTION: Some leaders showing strain"
+    else:
+        signal = "HEALTHY: Leadership intact"
+
+    return {
+        "score": final_score,
+        "signal": signal,
+        "avg_deterioration": round(avg_deterioration, 1),
+        "etfs_evaluated": len(etf_scores),
+        "etfs_deteriorating": deteriorating_count,
+        "deteriorating_pct": round(deteriorating_pct * 100, 1),
+        "amplified": deteriorating_pct >= 0.60,
+        "etf_details": etf_details,
+        "data_available": True,
+    }
+
+
+def _evaluate_etf(symbol: str, quote: Dict, history: List[Dict]) -> Dict:
+    """Evaluate a single ETF's deterioration level"""
+    score = 0
+    flags = []
+
+    price = quote.get("price", 0)
+    year_high = quote.get("yearHigh", 0)
+    year_low = quote.get("yearLow", 0)
+
+    # 1. Distance from 52-week high (0-40 points)
+    if year_high > 0:
+        distance_pct = (price - year_high) / year_high * 100
+        if distance_pct <= -25:
+            score += 40
+            flags.append(f">{abs(distance_pct):.0f}% below 52wk high (bear territory)")
+        elif distance_pct <= -15:
+            score += 30
+            flags.append(f"{abs(distance_pct):.0f}% below 52wk high (correction)")
+        elif distance_pct <= -10:
+            score += 20
+            flags.append(f"{abs(distance_pct):.0f}% below 52wk high")
+        elif distance_pct <= -5:
+            score += 10
+            flags.append(f"{abs(distance_pct):.0f}% below 52wk high")
+    else:
+        distance_pct = 0
+
+    # 2. Position vs moving averages (0-40 points)
+    if history and len(history) >= 50:
+        closes = [d.get("close", d.get("adjClose", 0)) for d in history]
+
+        # 50DMA
+        sma50 = sum(closes[:50]) / 50
+        if price < sma50:
+            score += 20
+            flags.append(f"Below 50DMA (${sma50:.2f})")
+
+        # 200DMA (if enough data)
+        if len(closes) >= 200:
+            sma200 = sum(closes[:200]) / 200
+            if price < sma200:
+                score += 20
+                flags.append(f"Below 200DMA (${sma200:.2f})")
+        elif len(closes) >= 50:
+            # Estimate 200DMA position from available data
+            if price < sma50 * 0.95:  # >5% below 50DMA suggests below 200DMA
+                score += 10
+                flags.append("Likely below 200DMA (estimated)")
+
+    elif history and len(history) >= 20:
+        closes = [d.get("close", d.get("adjClose", 0)) for d in history]
+        sma20 = sum(closes[:20]) / 20
+        if price < sma20:
+            score += 15
+            flags.append(f"Below 20DMA (${sma20:.2f})")
+
+    # 3. Lower highs pattern (0-20 points)
+    if history and len(history) >= 20:
+        lower_highs = _detect_lower_highs(history)
+        if lower_highs:
+            score += 20
+            flags.append("Lower highs pattern detected")
+
+    score = min(100, score)
+
+    return {
+        "deterioration_score": score,
+        "price": price,
+        "year_high": year_high,
+        "distance_from_high_pct": round(distance_pct, 1),
+        "flags": flags,
+    }
+
+
+def _detect_lower_highs(history: List[Dict], lookback: int = 20) -> bool:
+    """
+    Detect lower highs pattern in recent price action.
+
+    Look for at least 2 consecutive lower swing highs in the last 20 days.
+    """
+    if len(history) < lookback:
+        return False
+
+    highs = [d.get("high", d.get("close", 0)) for d in history[:lookback]]
+
+    # Find local maxima (swing highs)
+    swing_highs = []
+    for i in range(1, len(highs) - 1):
+        if highs[i] > highs[i-1] and highs[i] > highs[i+1]:
+            swing_highs.append(highs[i])
+
+    # Need at least 2 swing highs to compare
+    if len(swing_highs) < 2:
+        return False
+
+    # Check if most recent swing highs are declining
+    # swing_highs[0] is earliest (since history is most-recent-first, reversed)
+    # Actually history[0] = most recent, so highs[0] = most recent high
+    # So swing_highs are in reverse chronological order
+    return swing_highs[0] < swing_highs[1]