@vizzor/cli 0.13.1 → 0.14.5

package/chronovisor-engine/src/models/catalyst_event_model.py

@@ -0,0 +1,70 @@
+"""Catalyst and event-aware medium-horizon classifier."""
+
+import os
+from pathlib import Path
+
+import joblib
+import numpy as np
+
+MODEL_DIR = Path(os.getenv("MODEL_DIR", "models"))
+
+
+class CatalystEventModel:
+    FEATURE_KEYS = [
+        "days_to_event",
+        "event_risk",
+        "within_24h",
+        "within_72h",
+        "within_7d",
+        "is_fomc",
+        "is_cpi",
+        "is_nfp",
+        "returns_1d",
+        "returns_7d",
+        "volatility_14d",
+        "fear_greed",
+        "funding_rate",
+    ]
+
+    def __init__(self) -> None:
+        self.version = "0.1.0"
+        self.is_loaded = False
+        self.last_trained: str | None = None
+        self.accuracy: float | None = None
+        self.model = None
+
+    def load(self) -> None:
+        path = MODEL_DIR / "catalyst_event.joblib"
+        try:
+            data = joblib.load(path)
+            self.model = data["model"]
+            self.last_trained = data.get("trained_at")
+            self.accuracy = data.get("accuracy")
+            self.is_loaded = True
+        except Exception:
+            self.model = None
+            self.is_loaded = True
+
+    def predict(self, features: dict) -> dict:
+        if self.model is None:
+            event_risk = float(features.get("event_risk", 0.0))
+            ret = float(features.get("returns_1d", 0.0))
+            direction = "up" if ret > 1 else "down" if ret < -1 else "sideways"
+            probability = max(0.4, min(0.75, 0.55 + event_risk * 0.15))
+            return {
+                "direction": direction,
+                "probability": round(probability, 4),
+                "event_risk": round(event_risk, 4),
+                "model": "heuristic-catalyst-event",
+            }
+
+        x = np.array([[features.get(k, 0.0) for k in self.FEATURE_KEYS]], dtype=np.float32)
+        proba = self.model.predict_proba(x)[0]
+        idx = int(np.argmax(proba))
+        direction = {0: "down", 1: "sideways", 2: "up"}.get(idx, "sideways")
+        return {
+            "direction": direction,
+            "probability": round(float(proba[idx]), 4),
+            "event_risk": round(float(features.get("event_risk", 0.0)), 4),
+            "model": "catalyst_event",
+        }

package/chronovisor-engine/src/models/conformal_interval.py

@@ -0,0 +1,50 @@
+"""Distribution-free conformal interval calibrator for target forecasts."""
+
+import os
+from pathlib import Path
+
+import joblib
+
+MODEL_DIR = Path(os.getenv("MODEL_DIR", "models"))
+
+
+class ConformalIntervalModel:
+    def __init__(self) -> None:
+        self.version = "0.1.0"
+        self.is_loaded = False
+        self.last_trained: str | None = None
+        self.coverage: float | None = None
+        self.lower_residual_pct = 0.0
+        self.upper_residual_pct = 0.0
+
+    def load(self) -> None:
+        path = MODEL_DIR / "interval_conformal_calibrator.joblib"
+        try:
+            data = joblib.load(path)
+            self.lower_residual_pct = float(data.get("lower_residual_pct", 0.0))
+            self.upper_residual_pct = float(data.get("upper_residual_pct", 0.0))
+            self.coverage = data.get("coverage")
+            self.last_trained = data.get("trained_at")
+            self.is_loaded = True
+        except Exception:
+            self.is_loaded = True
+
+    def apply(self, low_change_pct: float, base_change_pct: float, high_change_pct: float) -> dict:
+        if self.lower_residual_pct == 0.0 and self.upper_residual_pct == 0.0:
+            return {
+                "low_change_pct": low_change_pct,
+                "base_change_pct": base_change_pct,
+                "high_change_pct": high_change_pct,
+                "coverage": self.coverage,
+                "model": "identity-conformal",
+            }
+
+        adjusted_low = min(low_change_pct, base_change_pct + self.lower_residual_pct)
+        adjusted_high = max(high_change_pct, base_change_pct + self.upper_residual_pct)
+        return {
+            "low_change_pct": round(adjusted_low, 4),
+            "base_change_pct": round(base_change_pct, 4),
+            "high_change_pct": round(adjusted_high, 4),
+            "coverage": self.coverage,
+            "model": "interval_conformal_calibrator",
+        }

package/chronovisor-engine/src/models/divergence_detector.py

@@ -0,0 +1,247 @@
+"""Detect divergence between prediction market odds and price action.
+
+Compares momentum signals from prediction markets (e.g., Polymarket odds)
+with token price action to identify bullish or bearish divergences where
+one signal leads the other.
+"""
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+import numpy as np
+
+MODEL_DIR = Path(os.getenv("MODEL_DIR", "models"))
+
+
+@dataclass
+class DivergenceResult:
+    """Result of divergence detection analysis."""
+
+    divergence_score: float  # 0-1, higher = more divergent
+    type: str  # 'bullish_divergence', 'bearish_divergence', 'no_divergence'
+    prediction_market_signal: float  # -1 to 1
+    price_action_signal: float  # -1 to 1
+    confidence: float
+    interpretation: str
+
+
+class DivergenceDetectorModel:
+    """Detects divergence between prediction market odds and price action.
+
+    When prediction market odds are bullish but price is declining, this
+    suggests a bullish divergence (odds tend to lead price). The reverse
+    indicates a bearish divergence.
+    """
+
+    def __init__(
+        self,
+        lookback_periods: int = 24,
+        divergence_threshold: float = 0.3,
+    ) -> None:
+        self.lookback_periods = lookback_periods
+        self.divergence_threshold = divergence_threshold
+        self.version = "0.1.0"
+        self.is_loaded = False
+        self.last_trained: str | None = None
+        self.accuracy: float | None = None
+
+    def load(self) -> None:
+        """Initialize model (analytical, always ready)."""
+        self.is_loaded = True
+
+    def detect(
+        self, market_odds: list[float], prices: list[float]
+    ) -> DivergenceResult:
+        """Detect divergence between prediction market odds and prices.
+
+        Args:
+            market_odds: Sequence of prediction market odds/probabilities (0-1).
+            prices: Sequence of token prices (any scale).
+
+        Returns:
+            DivergenceResult with scored divergence analysis.
+        """
+        if len(market_odds) < 2 or len(prices) < 2:
+            return DivergenceResult(
+                divergence_score=0.0,
+                type="no_divergence",
+                prediction_market_signal=0.0,
+                price_action_signal=0.0,
+                confidence=0.0,
+                interpretation="Insufficient data for divergence analysis.",
+            )
+
+        # Align lengths to minimum
+        min_len = min(len(market_odds), len(prices))
+        odds = np.array(market_odds[-min_len:], dtype=np.float64)
+        price = np.array(prices[-min_len:], dtype=np.float64)
+
+        # Use lookback window
+        window = min(self.lookback_periods, min_len)
+        odds_window = odds[-window:]
+        price_window = price[-window:]
+
+        # Calculate prediction market momentum (rate of change of odds)
+        pm_signal = self._calculate_momentum(odds_window)
+
+        # Calculate price momentum (returns)
+        price_signal = self._calculate_momentum(price_window)
+
+        # Calculate divergence score
+        divergence_score = abs(pm_signal - price_signal) / 2.0
+        divergence_score = min(1.0, max(0.0, divergence_score))
+
+        # Classify divergence type
+        divergence_type = self._classify_divergence(
+            pm_signal, price_signal, divergence_score
+        )
+
+        # Calculate confidence based on data quality and signal strength
+        confidence = self._calculate_confidence(
+            odds_window, price_window, divergence_score, min_len
+        )
+
+        # Generate interpretation
+        interpretation = self._generate_interpretation(
+            divergence_type, pm_signal, price_signal, divergence_score, confidence
+        )
+
+        return DivergenceResult(
+            divergence_score=round(divergence_score, 4),
+            type=divergence_type,
+            prediction_market_signal=round(pm_signal, 4),
+            price_action_signal=round(price_signal, 4),
+            confidence=round(confidence, 4),
+            interpretation=interpretation,
+        )
+
+    def predict(self, features: dict) -> DivergenceResult:
+        """API-compatible prediction.
+
+        Accepts: {"market_odds": [float], "prices": [float]}
+        """
+        market_odds = features.get("market_odds", [])
+        prices = features.get("prices", [])
+        return self.detect(market_odds, prices)
+
+    def _calculate_momentum(self, values: np.ndarray) -> float:
+        """Calculate normalized momentum signal from a value series.
+
+        Uses linear regression slope normalized to [-1, 1] range.
+        """
+        if len(values) < 2:
+            return 0.0
+
+        # Normalize values to [0, 1] for comparable slope calculation
+        v_min, v_max = float(np.min(values)), float(np.max(values))
+        if v_max - v_min < 1e-10:
+            return 0.0
+
+        normalized = (values - v_min) / (v_max - v_min)
+
+        # Linear regression slope
+        x = np.arange(len(normalized), dtype=np.float64)
+        x_mean = np.mean(x)
+        y_mean = np.mean(normalized)
+        numerator = float(np.sum((x - x_mean) * (normalized - y_mean)))
+        denominator = float(np.sum((x - x_mean) ** 2))
+
+        if abs(denominator) < 1e-10:
+            return 0.0
+
+        slope = numerator / denominator
+
+        # Scale slope to [-1, 1] — a slope of ~0.05 per period is strong
+        signal = np.tanh(slope * 10.0)
+        return float(signal)
+
+    def _classify_divergence(
+        self, pm_signal: float, price_signal: float, score: float
+    ) -> str:
+        """Classify the type of divergence."""
+        if score < self.divergence_threshold:
+            return "no_divergence"
+
+        # Odds bullish but price bearish → bullish divergence (odds lead)
+        if pm_signal > 0 and price_signal < 0:
+            return "bullish_divergence"
+
+        # Odds bearish but price bullish → bearish divergence (odds lead)
+        if pm_signal < 0 and price_signal > 0:
+            return "bearish_divergence"
+
+        # Both same direction but magnitude differs significantly
+        if abs(pm_signal - price_signal) > self.divergence_threshold:
+            if pm_signal > price_signal:
+                return "bullish_divergence"
+            return "bearish_divergence"
+
+        return "no_divergence"
+
+    def _calculate_confidence(
+        self,
+        odds: np.ndarray,
+        prices: np.ndarray,
+        divergence_score: float,
+        total_samples: int,
+    ) -> float:
+        """Calculate confidence in the divergence detection."""
+        # Data sufficiency factor
+        data_factor = min(1.0, total_samples / self.lookback_periods)
+
+        # Signal clarity — stronger signals = higher confidence
+        signal_factor = min(1.0, divergence_score / 0.8)
+
+        # Variance check — very noisy data reduces confidence
+        odds_std = float(np.std(odds))
+        price_std = float(np.std(prices))
+        price_mean = float(np.mean(prices))
+        noise_factor = 1.0
+        if price_mean != 0 and price_std / abs(price_mean) > 0.5:
+            noise_factor = 0.6
+        if odds_std > 0.3:
+            noise_factor *= 0.8
+
+        raw_confidence = (
+            data_factor * 0.3 + signal_factor * 0.5 + noise_factor * 0.2
+        )
+        return min(1.0, max(0.0, raw_confidence))
+
+    def _generate_interpretation(
+        self,
+        divergence_type: str,
+        pm_signal: float,
+        price_signal: float,
+        score: float,
+        confidence: float,
+    ) -> str:
+        """Generate a human-readable interpretation of the divergence."""
+        if divergence_type == "no_divergence":
+            return (
+                "No significant divergence detected between prediction "
+                "market odds and price action."
+            )
+
+        pm_dir = "bullish" if pm_signal > 0 else "bearish"
+        price_dir = "bullish" if price_signal > 0 else "bearish"
+        strength = "strong" if score > 0.6 else "moderate" if score > 0.4 else "mild"
+        conf_label = (
+            "high" if confidence > 0.7 else "moderate" if confidence > 0.4 else "low"
+        )
+
+        if divergence_type == "bullish_divergence":
+            return (
+                f"{strength.capitalize()} bullish divergence: prediction markets "
+                f"signal {pm_dir} ({pm_signal:+.2f}) while price action is "
+                f"{price_dir} ({price_signal:+.2f}). Odds may be leading price "
+                f"upward. Confidence: {conf_label} ({confidence:.0%})."
+            )
+
+        return (
+            f"{strength.capitalize()} bearish divergence: prediction markets "
+            f"signal {pm_dir} ({pm_signal:+.2f}) while price action is "
+            f"{price_dir} ({price_signal:+.2f}). Odds may be leading price "
+            f"downward. Confidence: {conf_label} ({confidence:.0%})."
+        )

package/chronovisor-engine/src/models/drift_monitor.py

@@ -0,0 +1,51 @@
+"""Simple PSI/z-score drift monitor for live feature health."""
+
+import os
+from pathlib import Path
+
+import joblib
+
+MODEL_DIR = Path(os.getenv("MODEL_DIR", "models"))
+
+
+class DriftMonitor:
+    def __init__(self) -> None:
+        self.version = "0.1.0"
+        self.is_loaded = False
+        self.last_trained: str | None = None
+        self.baseline: dict[str, dict[str, float]] = {}
+
+    def load(self) -> None:
+        path = MODEL_DIR / "meta_drift_detector.joblib"
+        try:
+            data = joblib.load(path)
+            self.baseline = data.get("baseline", {})
+            self.last_trained = data.get("trained_at")
+            self.is_loaded = True
+        except Exception:
+            self.baseline = {}
+            self.is_loaded = True
+
+    def check(self, features: dict) -> dict:
+        if not self.baseline:
+            return {"drift_score": 0.0, "status": "unknown", "alerts": [], "model": "identity-drift"}
+
+        alerts: list[str] = []
+        scores: list[float] = []
+        for name, stats in self.baseline.items():
+            value = float(features.get(name, stats.get("mean", 0.0)))
+            mean = float(stats.get("mean", 0.0))
+            std = max(float(stats.get("std", 0.0)), 1e-6)
+            z_score = abs(value - mean) / std
+            scores.append(min(1.0, z_score / 4.0))
+            if z_score >= 3:
+                alerts.append(f"{name}_z{z_score:.2f}")
+
+        drift_score = round(sum(scores) / len(scores), 4) if scores else 0.0
+        status = "high" if drift_score >= 0.6 else "moderate" if drift_score >= 0.3 else "stable"
+        return {
+            "drift_score": drift_score,
+            "status": status,
+            "alerts": alerts[:5],
+            "model": "meta_drift_detector",
+        }

package/chronovisor-engine/src/models/intent_classifier.py

@@ -0,0 +1,189 @@
+"""Intent Classifier — DistilBERT for user message intent classification."""
+
+import os
+import re
+from pathlib import Path
+
+import numpy as np
+
+MODEL_DIR = Path(os.getenv("MODEL_DIR", "models"))
+
+INTENTS = [
+    "price_query",
+    "trending",
+    "news",
+    "raises",
+    "pump_meme",
+    "analysis",
+    "prediction",
+    "broad_overview",
+    "agent_command",
+    "general",
+]
+
+
+class IntentClassifier:
+    """Classifies user message intent using fine-tuned DistilBERT or keyword heuristic."""
+
+    # Keyword arrays matching the TypeScript context-injector
+    PRICE_KEYWORDS = ["price", "worth", "cost", "value", "how much"]
+    TRENDING_KEYWORDS = ["trending", "hot", "popular", "top", "best", "hype"]
+    NEWS_KEYWORDS = ["news", "latest", "update", "happening", "announcement"]
+    RAISES_KEYWORDS = [
+        "ico", "ido", "launch", "raise", "funding", "fundrais", "invest", "new project"
+    ]
+    PUMP_KEYWORDS = ["pump", "meme", "solana launch", "pump.fun", "degen"]
+    ANALYSIS_KEYWORDS = [
+        "anali", "audit", "scan", "tokenomics", "rug", "security", "forensic",
+        "contract", "check", "review", "inspect", "investigate", "deep dive",
+        "full report", "due diligence"
+    ]
+    PREDICTION_KEYWORDS = [
+        "predict", "prediction", "forecast", "will it", "going to",
+        "should i buy", "should i sell", "compare", "vs", "versus",
+        "portfolio", "allocat", "diversif", "strategy", "risk", "hedge",
+        "long term", "short term", "entry", "exit", "target"
+    ]
+    BROAD_KEYWORDS = [
+        "what's happening", "whats happening", "market", "overview", "summary",
+        "up to date", "current", "right now", "today", "lately", "recently",
+        "this week", "this month", "general", "everything", "outlook",
+        "sentiment", "macro", "state of", "tell me about crypto", "crypto market"
+    ]
+    AGENT_KEYWORDS = [
+        "agent", "bot", "create agent", "start agent", "stop agent",
+        "list agent", "trading bot"
+    ]
+
+    # Common crypto token/address patterns
+    TOKEN_PATTERN = re.compile(r"\b(?:0x[a-fA-F0-9]{40}|[A-Z]{2,10}(?:USDT)?)\b")
+    ADDRESS_PATTERN = re.compile(r"0x[a-fA-F0-9]{40}")
+
+    def __init__(self) -> None:
+        self.version = "0.1.0"
+        self.is_loaded = False
+        self.last_trained: str | None = None
+        self.accuracy: float | None = None
+        self.model = None
+        self.tokenizer = None
+
+    def load(self) -> None:
+        model_path = MODEL_DIR / "intent_model"
+        try:
+            from transformers import AutoTokenizer, AutoModelForSequenceClassification
+            self.tokenizer = AutoTokenizer.from_pretrained(str(model_path))
+            self.model = AutoModelForSequenceClassification.from_pretrained(str(model_path))
+            self.last_trained = None
+            self.accuracy = None
+            self.is_loaded = True
+        except Exception:
+            self.model = None
+            self.tokenizer = None
+            self.is_loaded = True  # heuristic fallback
+
+    def classify(self, text: str) -> dict:
+        if self.model is not None and self.tokenizer is not None:
+            return self._classify_model(text)
+        return self._classify_heuristic(text)
+
+    def _classify_model(self, text: str) -> dict:
+        import torch
+
+        inputs = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=128)
+        with torch.no_grad():
+            logits = self.model(**inputs).logits
+        probs = torch.softmax(logits, dim=-1)[0].numpy()
+
+        top_idx = int(np.argmax(probs))
+        intent = INTENTS[top_idx] if top_idx < len(INTENTS) else "general"
+        confidence = float(probs[top_idx])
+
+        # Secondary intent
+        probs_copy = probs.copy()
+        probs_copy[top_idx] = 0
+        second_idx = int(np.argmax(probs_copy))
+        secondary = INTENTS[second_idx] if probs_copy[second_idx] > 0.15 else None
+
+        tokens, addresses = self._extract_entities(text)
+
+        return {
+            "intent": intent,
+            "confidence": round(confidence, 4),
+            "secondary_intent": secondary,
+            "detected_tokens": tokens,
+            "detected_addresses": addresses,
+            "model": "distilbert-intent",
+        }
+
+    def _classify_heuristic(self, text: str) -> dict:
+        lower = text.lower()
+
+        scores: dict[str, float] = {intent: 0 for intent in INTENTS}
+
+        # Match keywords
+        if self._matches_any(lower, self.PRICE_KEYWORDS):
+            scores["price_query"] += 1.0
+        if self._matches_any(lower, self.TRENDING_KEYWORDS):
+            scores["trending"] += 1.0
+        if self._matches_any(lower, self.NEWS_KEYWORDS):
+            scores["news"] += 1.0
+        if self._matches_any(lower, self.RAISES_KEYWORDS):
+            scores["raises"] += 1.0
+        if self._matches_any(lower, self.PUMP_KEYWORDS):
+            scores["pump_meme"] += 1.0
+        if self._matches_any(lower, self.ANALYSIS_KEYWORDS):
+            scores["analysis"] += 1.0
+        if self._matches_any(lower, self.PREDICTION_KEYWORDS):
+            scores["prediction"] += 1.0
+        if self._matches_any(lower, self.BROAD_KEYWORDS):
+            scores["broad_overview"] += 1.0
+        if self._matches_any(lower, self.AGENT_KEYWORDS):
+            scores["agent_command"] += 1.0
+
+        # Find top and secondary
+        sorted_intents = sorted(scores.items(), key=lambda x: x[1], reverse=True)
+        top_intent = sorted_intents[0][0]
+        top_score = sorted_intents[0][1]
+
+        if top_score == 0:
+            top_intent = "general"
+            confidence = 0.5
+        else:
+            total = sum(s for _, s in sorted_intents if s > 0)
+            confidence = top_score / total if total > 0 else 0.5
+
+        secondary = None
+        if len(sorted_intents) > 1 and sorted_intents[1][1] > 0:
+            secondary = sorted_intents[1][0]
+
+        tokens, addresses = self._extract_entities(text)
+
+        return {
+            "intent": top_intent,
+            "confidence": round(min(0.95, confidence), 4),
+            "secondary_intent": secondary,
+            "detected_tokens": tokens,
+            "detected_addresses": addresses,
+            "model": "keyword-intent",
+        }
+
+    @staticmethod
+    def _matches_any(text: str, keywords: list[str]) -> bool:
+        return any(kw in text for kw in keywords)
+
+    def _extract_entities(self, text: str) -> tuple[list[str], list[str]]:
+        addresses = self.ADDRESS_PATTERN.findall(text)
+
+        # Extract potential token symbols (uppercase 2-10 chars)
+        tokens = []
+        for word in text.split():
+            clean = word.strip(",.!?()[]{}:;\"'")
+            if (
+                clean.isupper()
+                and 2 <= len(clean) <= 10
+                and clean.isalpha()
+                and clean not in ("THE", "AND", "FOR", "BUT", "NOT", "ARE", "WAS", "HAS")
+            ):
+                tokens.append(clean)
+
+        return list(set(tokens))[:5], list(set(addresses))[:3]