quantwise 1.2.0 → 1.2.2

package/.claude/skills/market-breadth-analyzer/scripts/calculators/bearish_signal_calculator.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+"""
+Component 4: Bearish Signal Status (Weight: 15%)
+
+Evaluates the backtested bearish signal flag and its context.
+Also detects the "Pink Zone" (Bearish Region) from the source repository:
+  Pink Zone = Breadth_200MA_Trend == -1 AND 8MA < 200MA
+
+Input: Bearish_Signal, Breadth_200MA_Trend, Breadth_Index_8MA,
+       Breadth_Index_200MA (latest row)
+
+Scoring (100 = healthy):
+  Base:
+    Signal=False & Trend=1  -> 85 (all clear)
+    Signal=False & Trend=-1 -> 50 (no warning but downtrend)
+    Signal=True  & Trend=1  -> 30 (warning in uptrend)
+    Signal=True  & Trend=-1 -> 10 (fully bearish)
+
+  Context Adjustment:
+    Signal=True & 8MA > 0.50 -> +15 (weak signal amid strong breadth)
+    Signal=True & 8MA < 0.25 -> -5  (severe signal amid extreme weakness)
+
+  Pink Zone Adjustment:
+    In Pink Zone & Signal=False -> -10 (structural weakness even without signal)
+"""
+
+from typing import Dict, List
+
+
+def calculate_bearish_signal(rows: List[Dict]) -> Dict:
+    """
+    Calculate bearish signal status score.
+
+    Args:
+        rows: All detail rows sorted by date ascending.
+
+    Returns:
+        Dict with score, signal, and component details.
+    """
+    if not rows:
+        return {
+            "score": 50,
+            "signal": "NO DATA: No data available for bearish signal analysis",
+            "data_available": False,
+        }
+
+    latest = rows[-1]
+    signal_active = latest["Bearish_Signal"]
+    trend = latest["Breadth_200MA_Trend"]
+    ma8 = latest["Breadth_Index_8MA"]
+    ma200 = latest["Breadth_Index_200MA"]
+
+    # Pink Zone detection (from source repo: chart's pink background)
+    # Condition: 200MA trend declining AND 8MA below 200MA
+    in_pink_zone = (trend == -1) and (ma8 < ma200)
+
+    # Count consecutive pink zone days
+    pink_zone_days = 0
+    if in_pink_zone:
+        for i in range(len(rows) - 1, -1, -1):
+            r = rows[i]
+            if (r["Breadth_200MA_Trend"] == -1 and
+                    r["Breadth_Index_8MA"] < r["Breadth_Index_200MA"]):
+                pink_zone_days += 1
+            else:
+                break
+
+    # Base score
+    base_score = _base_score(signal_active, trend)
+
+    # Context adjustment
+    context_adj = 0
+    if signal_active:
+        if ma8 > 0.50:
+            context_adj = +15  # Weak signal amid strong breadth
+        elif ma8 < 0.25:
+            context_adj = -5  # Severe signal amid extreme weakness
+
+    # Pink Zone adjustment: structural weakness even without bearish signal
+    pink_zone_adj = 0
+    if in_pink_zone and not signal_active:
+        pink_zone_adj = -10
+
+    score = round(base_score + context_adj + pink_zone_adj)
+    score = max(0, min(100, score))
+
+    signal_text = _generate_signal(signal_active, trend, ma8, in_pink_zone, score)
+
+    return {
+        "score": score,
+        "signal": signal_text,
+        "data_available": True,
+        "signal_active": signal_active,
+        "trend": trend,
+        "current_8ma": ma8,
+        "current_200ma": ma200,
+        "in_pink_zone": in_pink_zone,
+        "pink_zone_days": pink_zone_days,
+        "base_score": base_score,
+        "context_adjustment": context_adj,
+        "pink_zone_adjustment": pink_zone_adj,
+        "date": latest["Date"],
+    }
+
+
+def _base_score(signal_active: bool, trend: int) -> int:
+    """Calculate base score from signal and trend combination."""
+    if not signal_active and trend == 1:
+        return 85  # All clear
+    elif not signal_active and trend == -1:
+        return 50  # No warning but downtrend
+    elif signal_active and trend == 1:
+        return 30  # Warning in uptrend
+    else:  # signal_active and trend == -1
+        return 10  # Fully bearish
+
+
+def _generate_signal(
+    signal_active: bool, trend: int, ma8: float,
+    in_pink_zone: bool, score: int,
+) -> str:
+    """Generate human-readable signal."""
+    trend_str = "uptrend" if trend == 1 else "downtrend"
+    pink_str = " [PINK ZONE]" if in_pink_zone else ""
+
+    if not signal_active:
+        if trend == 1:
+            return f"ALL CLEAR: No bearish signal, {trend_str}"
+        elif in_pink_zone:
+            return (
+                f"CAUTION: No bearish signal but in Pink Zone "
+                f"(downtrend + 8MA < 200MA){pink_str}"
+            )
+        else:
+            return f"CAUTION: No bearish signal but {trend_str}"
+    else:
+        if ma8 > 0.50:
+            return (
+                f"WARNING (muted): Bearish signal active in {trend_str}, "
+                f"but 8MA={ma8:.3f} still relatively strong{pink_str}"
+            )
+        elif ma8 < 0.25:
+            return (
+                f"CRITICAL: Bearish signal active in {trend_str}, "
+                f"8MA={ma8:.3f} extremely weak{pink_str}"
+            )
+        else:
+            return (
+                f"BEARISH: Signal active in {trend_str}, 8MA={ma8:.3f}{pink_str}"
+            )

package/.claude/skills/market-breadth-analyzer/scripts/calculators/cycle_calculator.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+"""
+Component 3: Peak/Trough Cycle Position (Weight: 20%)
+
+Determines where we are in the breadth cycle relative to recent peaks and troughs.
+
+Input: Is_Peak, Is_Trough, Is_Trough_8MA_Below_04, Breadth_Index_8MA (last 120 days)
+
+Scoring (100 = healthy):
+  Latest marker = TROUGH:
+    <= 20 days & 8MA rising       -> 85 (early recovery)
+    <= 20 days & 8MA flat/falling -> 30 (failed reversal)
+    21-60 days & 8MA rising       -> 75 (sustained recovery)
+    > 60 days & 8MA rising        -> 65 (mature recovery)
+
+  Latest marker = PEAK:
+    <= 20 days & 8MA falling      -> 20 (post-peak decline)
+    <= 20 days & 8MA flat/rising  -> 60 (high-level consolidation)
+    21-60 days & 8MA falling      -> 15 (sustained decline)
+    > 60 days & 8MA falling       -> 10 (prolonged decline)
+    > 60 days & 8MA rising        -> 50 (possible bottom formation)
+
+  Extreme Trough Bonus: Is_Trough_8MA_Below_04 == True -> +10
+  No marker within 120 days -> 50 (neutral)
+"""
+
+from typing import Dict, List, Optional, Tuple
+
+
+def calculate_cycle_position(rows: List[Dict]) -> Dict:
+    """
+    Calculate peak/trough cycle position score.
+
+    Args:
+        rows: All detail rows sorted by date ascending.
+
+    Returns:
+        Dict with score, signal, and component details.
+    """
+    if not rows or len(rows) < 10:
+        return {
+            "score": 50,
+            "signal": "NO DATA: Insufficient data for cycle analysis",
+            "data_available": False,
+        }
+
+    # Look at last 120 trading days
+    lookback = min(120, len(rows))
+    recent = rows[-lookback:]
+    latest = rows[-1]
+    current_8ma = latest["Breadth_Index_8MA"]
+
+    # Find latest peak or trough marker
+    marker_type, marker_idx, days_since = _find_latest_marker(recent)
+
+    # Determine 8MA trend (rising/falling) over last 5 days
+    if len(rows) >= 6:
+        ma8_trend = "rising" if current_8ma > rows[-6]["Breadth_Index_8MA"] else "falling"
+    else:
+        ma8_trend = "unknown"
+
+    # Check for extreme trough
+    extreme_trough = False
+    if marker_type == "TROUGH":
+        extreme_trough = recent[marker_idx]["Is_Trough_8MA_Below_04"]
+
+    # Calculate score
+    score = _calculate_score(marker_type, days_since, ma8_trend, extreme_trough)
+    score = max(0, min(100, score))
+
+    signal = _generate_signal(marker_type, days_since, ma8_trend, score)
+
+    return {
+        "score": score,
+        "signal": signal,
+        "data_available": True,
+        "latest_marker_type": marker_type,
+        "days_since_marker": days_since,
+        "ma8_trend": ma8_trend,
+        "current_8ma": current_8ma,
+        "extreme_trough": extreme_trough,
+        "date": latest["Date"],
+    }
+
+
+def _find_latest_marker(recent: List[Dict]) -> Tuple[Optional[str], int, Optional[int]]:
+    """
+    Find the most recent peak or trough marker.
+
+    Returns (marker_type, index_in_recent, days_since).
+    """
+    for i in range(len(recent) - 1, -1, -1):
+        row = recent[i]
+        if row["Is_Peak"]:
+            days_since = len(recent) - 1 - i
+            return "PEAK", i, days_since
+        if row["Is_Trough"] or row["Is_Trough_8MA_Below_04"]:
+            days_since = len(recent) - 1 - i
+            return "TROUGH", i, days_since
+
+    return None, -1, None
+
+
+def _calculate_score(
+    marker_type: Optional[str],
+    days_since: Optional[int],
+    ma8_trend: str,
+    extreme_trough: bool,
+) -> int:
+    """Calculate cycle position score based on marker and context."""
+    if marker_type is None or days_since is None:
+        return 50  # Neutral when no marker found
+
+    rising = ma8_trend == "rising"
+
+    if marker_type == "TROUGH":
+        if days_since <= 20:
+            base = 85 if rising else 30
+        elif days_since <= 60:
+            base = 75 if rising else 35
+        else:
+            base = 65 if rising else 40
+
+        # Extreme trough bonus (contrarian buy signal)
+        if extreme_trough:
+            base += 10
+
+    elif marker_type == "PEAK":
+        if days_since <= 20:
+            base = 60 if rising else 20
+        elif days_since <= 60:
+            base = 45 if rising else 15
+        else:
+            base = 50 if rising else 10
+
+    else:
+        base = 50
+
+    return base
+
+
+def _generate_signal(
+    marker_type: Optional[str],
+    days_since: Optional[int],
+    ma8_trend: str,
+    score: int,
+) -> str:
+    """Generate human-readable signal."""
+    if marker_type is None:
+        return "NEUTRAL: No cycle marker in last 120 days"
+
+    if marker_type == "TROUGH":
+        if days_since <= 20:
+            phase = "early recovery" if ma8_trend == "rising" else "failed reversal attempt"
+        elif days_since <= 60:
+            phase = "sustained recovery" if ma8_trend == "rising" else "stalled recovery"
+        else:
+            phase = "mature recovery" if ma8_trend == "rising" else "weakening recovery"
+        return f"TROUGH ({days_since}d ago): {phase}, 8MA {ma8_trend}"
+
+    else:  # PEAK
+        if days_since <= 20:
+            phase = "consolidation near highs" if ma8_trend == "rising" else "post-peak decline"
+        elif days_since <= 60:
+            phase = "gradual decline" if ma8_trend != "rising" else "recovery attempt"
+        else:
+            phase = "possible bottom formation" if ma8_trend == "rising" else "prolonged decline"
+        return f"PEAK ({days_since}d ago): {phase}, 8MA {ma8_trend}"

package/.claude/skills/market-breadth-analyzer/scripts/calculators/divergence_calculator.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""
+Component 6: S&P 500 vs Breadth Divergence (Weight: 10%)
+
+Detects divergence between price action and breadth participation.
+
+Input: S&P500_Price, Breadth_Index_8MA (last 60 days)
+
+Scoring (100 = healthy):
+  60-day changes:
+    sp500_pct = (latest - 60d_ago) / 60d_ago * 100
+    breadth_change = latest_8ma - 8ma_60d_ago
+
+  Both rising                        -> 70 (healthy rally)
+  Both falling                       -> 30 (consistent decline)
+  SP up(>3%) & Breadth down(<-0.05)  -> 10 (dangerous divergence)
+  SP up(>1%) & Breadth down(<-0.03)  -> 25
+  SP down(<-3%) & Breadth up(>+0.05) -> 80 (bullish divergence)
+  SP down(<-1%) & Breadth up(>+0.03) -> 65
+  Otherwise                          -> 50
+"""
+
+from typing import Dict, List
+
+
+def calculate_divergence(rows: List[Dict]) -> Dict:
+    """
+    Calculate S&P 500 vs breadth divergence score.
+
+    Args:
+        rows: All detail rows sorted by date ascending.
+
+    Returns:
+        Dict with score, signal, and component details.
+    """
+    if not rows or len(rows) < 60:
+        # Use whatever data is available, minimum 20 days
+        if not rows or len(rows) < 20:
+            return {
+                "score": 50,
+                "signal": "NO DATA: Insufficient data for divergence analysis",
+                "data_available": False,
+            }
+
+    lookback = min(60, len(rows))
+    latest = rows[-1]
+    past = rows[-lookback]
+
+    sp_latest = latest["S&P500_Price"]
+    sp_past = past["S&P500_Price"]
+    ma8_latest = latest["Breadth_Index_8MA"]
+    ma8_past = past["Breadth_Index_8MA"]
+
+    if sp_past <= 0:
+        return {
+            "score": 50,
+            "signal": "NO DATA: Invalid S&P 500 price data",
+            "data_available": False,
+        }
+
+    sp500_pct = (sp_latest - sp_past) / sp_past * 100
+    breadth_change = ma8_latest - ma8_past
+
+    # Determine divergence type and score
+    score, div_type = _score_divergence(sp500_pct, breadth_change)
+    score = max(0, min(100, score))
+
+    signal = _generate_signal(sp500_pct, breadth_change, div_type, score)
+
+    return {
+        "score": score,
+        "signal": signal,
+        "data_available": True,
+        "sp500_pct_change": round(sp500_pct, 2),
+        "breadth_change": round(breadth_change, 4),
+        "sp500_latest": sp_latest,
+        "sp500_past": sp_past,
+        "ma8_latest": ma8_latest,
+        "ma8_past": ma8_past,
+        "lookback_days": lookback,
+        "divergence_type": div_type,
+        "date": latest["Date"],
+    }
+
+
+def _score_divergence(sp_pct: float, breadth_chg: float) -> tuple:
+    """Score based on price/breadth divergence. Returns (score, type_label)."""
+    sp_up = sp_pct > 0
+    breadth_up = breadth_chg > 0
+
+    # Dangerous divergence: SP up, breadth down
+    if sp_pct > 3.0 and breadth_chg < -0.05:
+        return 10, "Dangerous bearish divergence"
+    if sp_pct > 1.0 and breadth_chg < -0.03:
+        return 25, "Moderate bearish divergence"
+
+    # Bullish divergence: SP down, breadth up
+    if sp_pct < -3.0 and breadth_chg > 0.05:
+        return 80, "Strong bullish divergence"
+    if sp_pct < -1.0 and breadth_chg > 0.03:
+        return 65, "Moderate bullish divergence"
+
+    # Aligned movements
+    if sp_up and breadth_up:
+        return 70, "Healthy alignment (both rising)"
+    if not sp_up and not breadth_up:
+        return 30, "Consistent decline (both falling)"
+
+    return 50, "Mixed signals"
+
+
+def _generate_signal(
+    sp_pct: float, breadth_chg: float, div_type: str, score: int
+) -> str:
+    """Generate human-readable signal."""
+    return (
+        f"{div_type}: S&P {sp_pct:+.1f}%, "
+        f"Breadth 8MA {breadth_chg:+.3f} over 60d"
+    )

package/.claude/skills/market-breadth-analyzer/scripts/calculators/historical_context_calculator.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""
+Component 5: Historical Percentile (Weight: 10%)
+
+Determines where the current breadth level sits in the full historical distribution.
+
+Input: Breadth_Index_8MA (all rows), Summary CSV (average peak/trough values)
+
+Scoring (100 = healthy):
+  Percentile rank of current 8MA among all historical 8MA values:
+    >= 80th -> 90    >= 60th -> 70    >= 40th -> 50
+    >= 20th -> 30    <  20th -> 10
+
+  Adjustment:
+    Current >= avg_peak * 0.95 -> -10 (overheated caution)
+    Current <= avg_trough * 1.05 -> +10 (oversold zone)
+"""
+
+from typing import Dict, List, Optional
+
+
+def calculate_historical_percentile(
+    rows: List[Dict],
+    summary: Dict[str, str],
+) -> Dict:
+    """
+    Calculate historical percentile score.
+
+    Args:
+        rows: All detail rows sorted by date ascending.
+        summary: Summary CSV as dict {Metric: Value}.
+
+    Returns:
+        Dict with score, signal, and component details.
+    """
+    if not rows:
+        return {
+            "score": 50,
+            "signal": "NO DATA: No data available for historical analysis",
+            "data_available": False,
+        }
+
+    # Extract all 8MA values
+    all_8ma = [r["Breadth_Index_8MA"] for r in rows]
+    current_8ma = all_8ma[-1]
+
+    # Calculate percentile rank
+    below_count = sum(1 for v in all_8ma if v < current_8ma)
+    percentile = (below_count / len(all_8ma)) * 100
+
+    # Base score from percentile
+    base_score = _score_percentile(percentile)
+
+    # Parse summary values
+    avg_peak = _safe_float(summary.get("Average Peaks (200MA)", ""))
+    avg_trough = _safe_float(summary.get("Average Troughs (8MA < 0.4)", ""))
+
+    # Adjustment for extremes
+    adjustment = 0
+    if avg_peak is not None and current_8ma >= avg_peak * 0.95:
+        adjustment = -10  # Overheated
+    elif avg_trough is not None and current_8ma <= avg_trough * 1.05:
+        adjustment = +10  # Oversold
+
+    score = round(base_score + adjustment)
+    score = max(0, min(100, score))
+
+    signal = _generate_signal(percentile, adjustment, score)
+
+    return {
+        "score": score,
+        "signal": signal,
+        "data_available": True,
+        "current_8ma": current_8ma,
+        "percentile_rank": percentile,
+        "base_score": base_score,
+        "adjustment": adjustment,
+        "avg_peak": avg_peak,
+        "avg_trough": avg_trough,
+        "total_observations": len(all_8ma),
+        "date": rows[-1]["Date"],
+    }
+
+
+def _score_percentile(percentile: float) -> int:
+    """Score from percentile rank."""
+    if percentile >= 80:
+        return 90
+    elif percentile >= 60:
+        return 70
+    elif percentile >= 40:
+        return 50
+    elif percentile >= 20:
+        return 30
+    else:
+        return 10
+
+
+def _safe_float(val: str) -> Optional[float]:
+    """Safely parse float from string."""
+    try:
+        return float(val)
+    except (ValueError, TypeError):
+        return None
+
+
+def _generate_signal(percentile: float, adjustment: int, score: int) -> str:
+    """Generate human-readable signal."""
+    adj_str = ""
+    if adjustment < 0:
+        adj_str = " (near historical peak - overheated)"
+    elif adjustment > 0:
+        adj_str = " (near historical trough - oversold)"
+
+    if score >= 70:
+        return f"HIGH: {percentile:.0f}th percentile - above average breadth{adj_str}"
+    elif score >= 40:
+        return f"AVERAGE: {percentile:.0f}th percentile - normal range{adj_str}"
+    else:
+        return f"LOW: {percentile:.0f}th percentile - below average breadth{adj_str}"

package/.claude/skills/market-breadth-analyzer/scripts/calculators/ma_crossover_calculator.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+"""
+Component 2: 8MA vs 200MA Crossover Dynamics (Weight: 20%)
+
+Detects momentum and direction changes via the gap between fast and slow MAs.
+
+Input: Breadth_Index_8MA, Breadth_Index_200MA (latest + 5-day lookback)
+
+Scoring (100 = healthy):
+  Gap = 8MA - 200MA
+    >= +0.15 -> 95    >= +0.10 -> 80    >= +0.05 -> 65
+    >=  0.00 -> 50    >= -0.05 -> 35    >= -0.10 -> 20
+    <  -0.10 -> 5
+
+  Direction Modifier (5-day 8MA trend):
+    Gap < 0 and 8MA rising  -> +10 (recovery signal)
+    Gap > 0 and 8MA falling -> -10 (deterioration signal)
+"""
+
+from typing import Dict, List
+
+
+def calculate_ma_crossover(rows: List[Dict]) -> Dict:
+    """
+    Calculate 8MA vs 200MA crossover dynamics score.
+
+    Args:
+        rows: All detail rows sorted by date ascending.
+
+    Returns:
+        Dict with score, signal, and component details.
+    """
+    if not rows or len(rows) < 6:
+        return {
+            "score": 50,
+            "signal": "NO DATA: Insufficient data for crossover analysis",
+            "data_available": False,
+        }
+
+    latest = rows[-1]
+    ma8 = latest["Breadth_Index_8MA"]
+    ma200 = latest["Breadth_Index_200MA"]
+    gap = ma8 - ma200
+
+    # Gap score
+    gap_score = _score_gap(gap)
+
+    # 8MA direction over last 5 days
+    ma8_5d_ago = rows[-6]["Breadth_Index_8MA"]
+    ma8_rising = ma8 > ma8_5d_ago
+    ma8_direction = "rising" if ma8_rising else "falling"
+
+    # Direction modifier
+    direction_modifier = 0
+    if gap < 0 and ma8_rising:
+        direction_modifier = +10  # Recovery signal
+    elif gap > 0 and not ma8_rising:
+        direction_modifier = -10  # Deterioration signal
+
+    score = round(gap_score + direction_modifier)
+    score = max(0, min(100, score))
+
+    signal = _generate_signal(gap, ma8_direction, direction_modifier, score)
+
+    return {
+        "score": score,
+        "signal": signal,
+        "data_available": True,
+        "gap": gap,
+        "gap_score": gap_score,
+        "current_8ma": ma8,
+        "current_200ma": ma200,
+        "ma8_5d_ago": ma8_5d_ago,
+        "ma8_direction": ma8_direction,
+        "direction_modifier": direction_modifier,
+        "date": latest["Date"],
+    }
+
+
+def _score_gap(gap: float) -> int:
+    """Score based on 8MA - 200MA gap."""
+    if gap >= 0.15:
+        return 95
+    elif gap >= 0.10:
+        return 80
+    elif gap >= 0.05:
+        return 65
+    elif gap >= 0.00:
+        return 50
+    elif gap >= -0.05:
+        return 35
+    elif gap >= -0.10:
+        return 20
+    else:
+        return 5
+
+
+def _generate_signal(gap: float, direction: str, modifier: int, score: int) -> str:
+    """Generate human-readable signal."""
+    mod_str = ""
+    if modifier > 0:
+        mod_str = " (recovery signal)"
+    elif modifier < 0:
+        mod_str = " (deterioration signal)"
+
+    if score >= 80:
+        return f"BULLISH: 8MA well above 200MA (gap={gap:+.3f}, 8MA {direction}){mod_str}"
+    elif score >= 60:
+        return f"POSITIVE: 8MA above 200MA (gap={gap:+.3f}, 8MA {direction}){mod_str}"
+    elif score >= 40:
+        return f"NEUTRAL: Near crossover (gap={gap:+.3f}, 8MA {direction}){mod_str}"
+    elif score >= 20:
+        return f"NEGATIVE: 8MA below 200MA (gap={gap:+.3f}, 8MA {direction}){mod_str}"
+    else:
+        return f"BEARISH: 8MA far below 200MA (gap={gap:+.3f}, 8MA {direction}){mod_str}"