@vizzor/cli 0.13.1 → 0.14.6

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

@@ -0,0 +1,127 @@
+"""Regime Detector — Hidden Markov Model for market regime classification."""
+
+import os
+from pathlib import Path
+
+import joblib
+import numpy as np
+
+MODEL_DIR = Path(os.getenv("MODEL_DIR", "models"))
+
+REGIMES = ["trending_bull", "trending_bear", "ranging", "volatile", "capitulation"]
+
+
+class RegimeDetector:
+    """Detects the current market regime using HMM or heuristic fallback."""
+
+    FEATURE_KEYS = [
+        "returns_1d",
+        "returns_7d",
+        "volatility_14d",
+        "volume_ratio",
+        "rsi",
+        "bb_width",
+        "fear_greed",
+        "funding_rate",
+        "price_vs_sma200",
+    ]
+
+    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.engine = "heuristic"
+
+    def load(self) -> None:
+        model_path = MODEL_DIR / "regime_detector.joblib"
+        try:
+            data = joblib.load(model_path)
+            self.model = data["model"]
+            self.engine = data.get("engine", "random_forest")
+            self.last_trained = data.get("trained_at")
+            self.accuracy = data.get("accuracy")
+            self.is_loaded = True
+        except Exception:
+            self.model = None
+            self.engine = "heuristic"
+            self.is_loaded = True  # heuristic fallback ready
+
+    def predict(self, features: dict) -> dict:
+        if self.model is not None:
+            return self._predict_model(features)
+        return self._predict_heuristic(features)
+
+    def _predict_model(self, features: dict) -> dict:
+        x = np.array([[features.get(k, 0) for k in self.FEATURE_KEYS]])
+
+        # HMM predict returns state index
+        state = int(self.model.predict(x)[0])
+        regime = REGIMES[state] if state < len(REGIMES) else "ranging"
+
+        # State probabilities
+        log_prob = self.model.score(x)
+        # Approximate probabilities using posterior
+        try:
+            posteriors = self.model.predict_proba(x)[0]
+            probabilities = {}
+            for i, r in enumerate(REGIMES):
+                probabilities[r] = round(float(posteriors[i]), 4) if i < len(posteriors) else 0.0
+        except Exception:
+            probabilities = {r: (0.8 if r == regime else 0.05) for r in REGIMES}
+
+        confidence = probabilities.get(regime, 0.5) * 100
+
+        return {
+            "regime": regime,
+            "confidence": round(min(100, confidence), 2),
+            "probabilities": probabilities,
+            "model": f"{self.engine}-regime-detector",
+        }
+
+    def _predict_heuristic(self, features: dict) -> dict:
+        vol = features.get("volatility_14d", 3)
+        ret7d = features.get("returns_7d", 0)
+        fg = features.get("fear_greed", 50)
+        rsi = features.get("rsi", 50)
+
+        # Classification rules
+        if fg < 15 and ret7d < -20:
+            regime = "capitulation"
+            confidence = 80
+        elif vol > 8:
+            regime = "volatile"
+            confidence = 70
+        elif vol > 5 and ret7d > 10:
+            regime = "trending_bull"
+            confidence = 65
+        elif vol > 5 and ret7d < -10:
+            regime = "trending_bear"
+            confidence = 65
+        elif ret7d > 5 and rsi > 55:
+            regime = "trending_bull"
+            confidence = 55
+        elif ret7d < -5 and rsi < 45:
+            regime = "trending_bear"
+            confidence = 55
+        else:
+            regime = "ranging"
+            confidence = 60
+
+        # Build approximate probabilities
+        probabilities = {r: 0.05 for r in REGIMES}
+        probabilities[regime] = confidence / 100
+
+        # Distribute remaining probability
+        remaining = 1.0 - probabilities[regime]
+        others = [r for r in REGIMES if r != regime]
+        for r in others:
+            probabilities[r] = round(remaining / len(others), 4)
+
+        return {
+            "regime": regime,
+            "confidence": round(confidence, 2),
+            "probabilities": probabilities,
+            "model": "heuristic-regime-detector",
+        }

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

@@ -0,0 +1,197 @@
+"""Gradient Boosted classifier for rug pull detection.
+
+Input: token metadata (bytecode size, verification, holder concentration,
+       GoPlus security flags, contract age, transfer count, tax rates).
+Output: rug probability + risk factors.
+
+Trained on historical rug pull database. Heuristic fallback when untrained.
+"""
+
+import os
+from pathlib import Path
+
+import numpy as np
+
+MODEL_DIR = Path(os.getenv("MODEL_DIR", "models"))
+
+FEATURE_KEYS = [
+    "bytecode_size",
+    "is_verified",
+    "holder_concentration",
+    "has_proxy",
+    "has_mint",
+    "has_pause",
+    "has_blacklist",
+    "liquidity_locked",
+    "buy_tax",
+    "sell_tax",
+    "contract_age_days",
+    "total_transfers",
+    "owner_balance_pct",
+    "is_open_source",
+    "top10_holder_pct",
+]
+
+
+class RugDetector:
+    def __init__(self):
+        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):
+        """Load trained GBM model or use heuristic."""
+        model_path = MODEL_DIR / "rug_detector.joblib"
+        if model_path.exists():
+            try:
+                import joblib
+
+                self.model = joblib.load(model_path)
+                self.is_loaded = True
+                self.last_trained = str(model_path.stat().st_mtime)
+            except Exception:
+                self._init_heuristic()
+        else:
+            self._init_heuristic()
+
+    def _init_heuristic(self):
+        self.is_loaded = True
+        self.version = "0.1.0-heuristic"
+
+    def predict(self, features: dict) -> dict:
+        """Predict rug pull probability.
+
+        Returns:
+            dict with: rug_probability, risk_level, risk_factors, model
+        """
+        if self.model is not None:
+            return self._predict_model(features)
+        return self._predict_heuristic(features)
+
+    def _predict_model(self, features: dict) -> dict:
+        """Run inference through trained Gradient Boosted classifier."""
+        X = np.array([[features.get(k, 0) for k in FEATURE_KEYS]])
+        proba = self.model.predict_proba(X)[0]
+        # Assume class 1 = rug
+        rug_idx = list(self.model.classes_).index(1) if 1 in self.model.classes_ else -1
+        rug_prob = float(proba[rug_idx]) if rug_idx >= 0 else 0.0
+
+        # Feature importance for explanations
+        importances = self.model.feature_importances_
+        top_factors = sorted(
+            zip(FEATURE_KEYS, importances, [features.get(k, 0) for k in FEATURE_KEYS]),
+            key=lambda x: x[1],
+            reverse=True,
+        )[:5]
+
+        risk_factors = []
+        for name, importance, value in top_factors:
+            if importance > 0.05:
+                risk_factors.append({
+                    "factor": name,
+                    "importance": round(float(importance), 3),
+                    "value": value,
+                })
+
+        return {
+            "rug_probability": round(rug_prob, 4),
+            "risk_level": self._level(rug_prob),
+            "risk_factors": risk_factors,
+            "model": f"rug-detector-{self.version}",
+        }
+
+    def _predict_heuristic(self, features: dict) -> dict:
+        """Weighted rule-based rug detection until model is trained."""
+        score = 0.0
+        risk_factors = []
+
+        # --- Critical indicators ---
+
+        has_mint = features.get("has_mint", 0)
+        if has_mint:
+            score += 0.20
+            risk_factors.append({"factor": "has_mint", "importance": 0.20, "value": 1})
+
+        has_blacklist = features.get("has_blacklist", 0)
+        if has_blacklist:
+            score += 0.15
+            risk_factors.append({"factor": "has_blacklist", "importance": 0.15, "value": 1})
+
+        sell_tax = features.get("sell_tax", 0)
+        if sell_tax > 10:
+            score += 0.20
+            risk_factors.append({"factor": "sell_tax", "importance": 0.20, "value": sell_tax})
+        elif sell_tax > 5:
+            score += 0.10
+            risk_factors.append({"factor": "sell_tax", "importance": 0.10, "value": sell_tax})
+
+        # --- Warning indicators ---
+
+        is_verified = features.get("is_verified", 0)
+        if not is_verified:
+            score += 0.10
+            risk_factors.append({"factor": "is_verified", "importance": 0.10, "value": 0})
+
+        has_proxy = features.get("has_proxy", 0)
+        if has_proxy:
+            score += 0.08
+            risk_factors.append({"factor": "has_proxy", "importance": 0.08, "value": 1})
+
+        holder_conc = features.get("holder_concentration", 0)
+        if holder_conc > 50:
+            score += 0.15
+            risk_factors.append({"factor": "holder_concentration", "importance": 0.15, "value": holder_conc})
+        elif holder_conc > 30:
+            score += 0.08
+            risk_factors.append({"factor": "holder_concentration", "importance": 0.08, "value": holder_conc})
+
+        liquidity_locked = features.get("liquidity_locked", 0)
+        if not liquidity_locked:
+            score += 0.10
+            risk_factors.append({"factor": "liquidity_locked", "importance": 0.10, "value": 0})
+
+        # --- Contextual ---
+
+        contract_age = features.get("contract_age_days", 0)
+        if contract_age < 7:
+            score += 0.08
+            risk_factors.append({"factor": "contract_age_days", "importance": 0.08, "value": contract_age})
+
+        total_transfers = features.get("total_transfers", 0)
+        if total_transfers < 50:
+            score += 0.05
+            risk_factors.append({"factor": "total_transfers", "importance": 0.05, "value": total_transfers})
+
+        owner_pct = features.get("owner_balance_pct", 0)
+        if owner_pct > 20:
+            score += 0.10
+            risk_factors.append({"factor": "owner_balance_pct", "importance": 0.10, "value": owner_pct})
+
+        has_pause = features.get("has_pause", 0)
+        if has_pause:
+            score += 0.08
+            risk_factors.append({"factor": "has_pause", "importance": 0.08, "value": 1})
+
+        rug_prob = min(0.98, score)
+
+        # Sort by importance
+        risk_factors.sort(key=lambda x: x["importance"], reverse=True)
+
+        return {
+            "rug_probability": round(rug_prob, 4),
+            "risk_level": self._level(rug_prob),
+            "risk_factors": risk_factors[:5],
+            "model": "rug-detector-heuristic",
+        }
+
+    @staticmethod
+    def _level(prob: float) -> str:
+        if prob >= 0.75:
+            return "critical"
+        if prob >= 0.50:
+            return "high"
+        if prob >= 0.25:
+            return "medium"
+        return "low"

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

@@ -0,0 +1,257 @@
+"""NLP sentiment analyzer for crypto news.
+
+Input: news article text (headline + optional body)
+Output: sentiment (bullish/bearish/neutral) + confidence + key_topics.
+
+Uses DistilBERT fine-tuned on crypto domain when trained model available.
+Heuristic fallback uses keyword-based sentiment scoring.
+"""
+
+import os
+import re
+from pathlib import Path
+
+MODEL_DIR = Path(os.getenv("MODEL_DIR", "models"))
+
+# Crypto-specific sentiment keywords
+BULLISH_KEYWORDS = [
+    "surge", "soar", "rally", "breakout", "bullish", "moon", "pump",
+    "adoption", "partnership", "listing", "launch", "upgrade", "approval",
+    "etf approved", "institutional", "accumulation", "inflow", "buy signal",
+    "golden cross", "all-time high", "ath", "massive", "growth",
+    "breakthrough", "milestone", "record", "explode", "skyrocket",
+    "optimistic", "recovery", "rebound", "flip", "outperform",
+]
+
+BEARISH_KEYWORDS = [
+    "crash", "dump", "plunge", "bearish", "collapse", "sell-off",
+    "hack", "exploit", "rug", "scam", "fraud", "lawsuit", "sec",
+    "regulation", "ban", "restriction", "investigation", "fud",
+    "death cross", "capitulation", "outflow", "liquidation", "bankrupt",
+    "insolvency", "ponzi", "warning", "risk", "vulnerable", "breach",
+    "shutdown", "delisted", "reject", "decline", "drop", "fear",
+    "whale dump", "exit scam", "money laundering",
+]
+
+NEUTRAL_MODIFIERS = [
+    "might", "could", "may", "uncertain", "mixed", "sideways",
+    "consolidation", "range-bound", "flat", "stable",
+]
+
+
+class SentimentAnalyzer:
+    def __init__(self):
+        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
+        self.model_type = "heuristic"
+
+    def load(self):
+        """Load trained transformer or sklearn pipeline; otherwise use heuristic."""
+        transformer_path = MODEL_DIR / "sentiment_model"
+        sklearn_path = MODEL_DIR / "sentiment_nlp.joblib"
+
+        if transformer_path.exists():
+            try:
+                from transformers import AutoModelForSequenceClassification, AutoTokenizer
+
+                self.tokenizer = AutoTokenizer.from_pretrained(str(transformer_path))
+                self.model = AutoModelForSequenceClassification.from_pretrained(str(transformer_path))
+                self.is_loaded = True
+                self.last_trained = str(transformer_path.stat().st_mtime)
+                self.model_type = "transformers"
+                return
+            except Exception:
+                pass
+
+        if sklearn_path.exists():
+            try:
+                import joblib
+
+                data = joblib.load(sklearn_path)
+                if isinstance(data, dict) and "model" in data:
+                    self.model = data["model"]
+                    self.accuracy = data.get("accuracy")
+                    self.last_trained = data.get("trained_at") or str(sklearn_path.stat().st_mtime)
+                else:
+                    self.model = data
+                    self.last_trained = str(sklearn_path.stat().st_mtime)
+
+                self.tokenizer = None
+                self.model_type = "sklearn"
+                self.is_loaded = True
+                return
+            except Exception:
+                pass
+
+        self._init_heuristic()
+
+    def _init_heuristic(self):
+        self.is_loaded = True
+        self.version = "0.1.0-heuristic"
+        self.model_type = "heuristic"
+
+    def analyze(self, text: str) -> dict:
+        """Analyze sentiment of text.
+
+        Returns:
+            dict with: sentiment, confidence, score, key_topics, model
+        """
+        if self.model is not None and self.model_type == "transformers" and self.tokenizer is not None:
+            return self._analyze_transformers(text)
+        if self.model is not None and self.model_type == "sklearn":
+            return self._analyze_sklearn(text)
+        return self._analyze_heuristic(text)
+
+    def analyze_batch(self, texts: list[str]) -> list[dict]:
+        """Analyze sentiment for multiple texts."""
+        return [self.analyze(t) for t in texts]
+
+    def _analyze_transformers(self, text: str) -> dict:
+        """Run inference through trained DistilBERT."""
+        import torch
+
+        inputs = self.tokenizer(
+            text, return_tensors="pt", truncation=True, max_length=256, padding=True
+        )
+
+        with torch.no_grad():
+            outputs = self.model(**inputs)
+            probs = torch.softmax(outputs.logits, dim=-1).squeeze().numpy()
+
+        # Classes: bearish=0, neutral=1, bullish=2
+        labels = ["bearish", "neutral", "bullish"]
+        idx = int(probs.argmax())
+        sentiment = labels[idx]
+        confidence = float(probs[idx])
+
+        # Score: -1 (bearish) to +1 (bullish)
+        score = float(probs[2] - probs[0])
+
+        return {
+            "sentiment": sentiment,
+            "confidence": round(confidence, 3),
+            "score": round(score, 4),
+            "key_topics": self._extract_topics(text),
+            "model": f"sentiment-nlp-{self.version}",
+        }
+
+    def _analyze_sklearn(self, text: str) -> dict:
+        """Run inference through a saved sklearn text pipeline."""
+        probs = self.model.predict_proba([text])[0]
+        classes = list(self.model.classes_)
+        idx = int(probs.argmax())
+        sentiment = str(classes[idx])
+        confidence = float(probs[idx])
+
+        bearish_idx = classes.index("bearish") if "bearish" in classes else None
+        bullish_idx = classes.index("bullish") if "bullish" in classes else None
+        bearish_prob = float(probs[bearish_idx]) if bearish_idx is not None else 0.0
+        bullish_prob = float(probs[bullish_idx]) if bullish_idx is not None else 0.0
+
+        return {
+            "sentiment": sentiment,
+            "confidence": round(confidence, 3),
+            "score": round(bullish_prob - bearish_prob, 4),
+            "key_topics": self._extract_topics(text),
+            "model": "sentiment-nlp-sklearn",
+        }
+
+    def _analyze_heuristic(self, text: str) -> dict:
+        """Keyword-based sentiment analysis."""
+        text_lower = text.lower()
+        words = set(re.findall(r'\b\w+\b', text_lower))
+
+        bullish_score = 0.0
+        bearish_score = 0.0
+        matched_bull = []
+        matched_bear = []
+
+        for keyword in BULLISH_KEYWORDS:
+            if keyword in text_lower:
+                weight = 1.5 if len(keyword.split()) > 1 else 1.0
+                bullish_score += weight
+                matched_bull.append(keyword)
+
+        for keyword in BEARISH_KEYWORDS:
+            if keyword in text_lower:
+                weight = 1.5 if len(keyword.split()) > 1 else 1.0
+                bearish_score += weight
+                matched_bear.append(keyword)
+
+        # Negation handling
+        negation_patterns = [
+            r"not\s+\w+",
+            r"no\s+\w+",
+            r"never\s+\w+",
+            r"without\s+\w+",
+            r"fail(ed|s)?\s+to",
+        ]
+        negation_count = sum(
+            len(re.findall(pattern, text_lower))
+            for pattern in negation_patterns
+        )
+        if negation_count > 0:
+            bullish_score, bearish_score = bearish_score * 0.5, bullish_score * 0.5
+
+        # Neutral modifiers reduce confidence
+        neutral_count = sum(1 for m in NEUTRAL_MODIFIERS if m in words)
+        uncertainty_factor = max(0.5, 1.0 - neutral_count * 0.15)
+
+        total = bullish_score + bearish_score
+        if total == 0:
+            return {
+                "sentiment": "neutral",
+                "confidence": 0.5,
+                "score": 0.0,
+                "key_topics": self._extract_topics(text),
+                "model": "sentiment-heuristic",
+            }
+
+        net_score = (bullish_score - bearish_score) / max(total, 1)
+        confidence = min(0.95, (total / 5.0) * uncertainty_factor)
+
+        if net_score > 0.2:
+            sentiment = "bullish"
+        elif net_score < -0.2:
+            sentiment = "bearish"
+        else:
+            sentiment = "neutral"
+
+        return {
+            "sentiment": sentiment,
+            "confidence": round(confidence, 3),
+            "score": round(net_score, 4),
+            "key_topics": self._extract_topics(text),
+            "model": "sentiment-heuristic",
+        }
+
+    @staticmethod
+    def _extract_topics(text: str) -> list[str]:
+        """Extract crypto-relevant topics from text."""
+        topics = []
+        text_lower = text.lower()
+
+        topic_patterns = {
+            "regulation": ["sec", "regulation", "ban", "lawsuit", "compliance", "legal"],
+            "defi": ["defi", "dex", "lending", "yield", "liquidity", "amm", "tvl"],
+            "nft": ["nft", "opensea", "collectible", "pfp", "mint"],
+            "layer2": ["l2", "layer 2", "rollup", "zk-", "optimistic", "arbitrum", "base"],
+            "bitcoin": ["bitcoin", "btc", "halving", "miner", "satoshi"],
+            "ethereum": ["ethereum", "eth", "merge", "staking", "beacon"],
+            "ai": ["ai", "artificial intelligence", "machine learning", "gpt", "llm"],
+            "gaming": ["gaming", "gamefi", "metaverse", "play-to-earn", "p2e"],
+            "security": ["hack", "exploit", "breach", "vulnerability", "audit"],
+            "exchange": ["exchange", "listing", "binance", "coinbase", "trading"],
+            "macro": ["fed", "interest rate", "inflation", "recession", "gdp"],
+            "meme": ["meme", "doge", "shib", "pepe", "pump.fun"],
+        }
+
+        for topic, keywords in topic_patterns.items():
+            if any(kw in text_lower for kw in keywords):
+                topics.append(topic)
+
+        return topics[:5]