nextrade-engine 0.5.0__py3-none-any.whl

nextrade/nextrade/core/brain.py

@@ -0,0 +1,278 @@
+"""
+NexTrade — Brain
+File otak utama NexTrade. Mengatur IQ model, neuron aktif,
+mode learning, dan agresivitas sinyal.
+"""
+
+import json
+import os
+import numpy as np
+from datetime import datetime
+
+# Path simpan state otak
+BRAIN_FILE = os.path.join(os.path.dirname(__file__), "brain_state.json")
+
+# ─────────────────────────────────────────
+# DEFAULT STATE OTAK
+# ─────────────────────────────────────────
+DEFAULT_STATE = {
+    "iq"              : 50,        # IQ awal model (0-100)
+    "neurons_active"  : 100,       # neuron aktif saat ini
+    "neurons_total"   : 2000,      # total neuron maksimal
+    "agresivitas"     : 30,        # % agresivitas sinyal (0-100)
+    "mode"            : "hybrid",  # offline / online / hybrid
+    "total_predictions": 0,        # total prediksi yang pernah dibuat
+    "correct_predictions": 0,      # prediksi yang benar
+    "last_updated"    : "",        # kapan terakhir belajar
+    "learning_sessions": 0,        # berapa kali sudah belajar
+    "weights"         : {},        # bobot internal model
+}
+
+# ─────────────────────────────────────────
+# LABEL AGRESIVITAS
+# ─────────────────────────────────────────
+def _agresivitas_label(pct: int) -> str:
+    if pct <= 30:   return "Konservatif"
+    elif pct <= 60: return "Moderat"
+    else:           return "Agresif"
+
+def _iq_label(iq: int) -> str:
+    if iq < 30:  return "Pemula"
+    elif iq < 50: return "Berkembang"
+    elif iq < 70: return "Cukup Cerdas"
+    elif iq < 85: return "Cerdas"
+    elif iq < 95: return "Sangat Cerdas"
+    else:         return "Jenius"
+
+def _bar(value: int, total: int = 100, width: int = 16) -> str:
+    filled = int((value / total) * width)
+    return "█" * filled + "░" * (width - filled)
+
+# ─────────────────────────────────────────
+# LOAD / SAVE STATE
+# ─────────────────────────────────────────
+def _load_state() -> dict:
+    if os.path.exists(BRAIN_FILE):
+        try:
+            with open(BRAIN_FILE, "r") as f:
+                saved = json.load(f)
+                state = DEFAULT_STATE.copy()
+                state.update(saved)
+                return state
+        except:
+            pass
+    return DEFAULT_STATE.copy()
+
+def _save_state(state: dict):
+    state["last_updated"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    with open(BRAIN_FILE, "w") as f:
+        json.dump(state, f, indent=2)
+
+# ─────────────────────────────────────────
+# HITUNG IQ DARI PERFORMA
+# ─────────────────────────────────────────
+def _calculate_iq(state: dict) -> int:
+    total = state["total_predictions"]
+    correct = state["correct_predictions"]
+    sessions = state["learning_sessions"]
+    neuron_ratio = state["neurons_active"] / state["neurons_total"]
+
+    if total == 0:
+        base_iq = 50
+    else:
+        winrate = correct / total
+        base_iq = winrate * 80  # max 80 dari winrate
+
+    # Bonus dari sesi belajar (max +10)
+    session_bonus = min(sessions * 0.5, 10)
+
+    # Bonus dari neuron aktif (max +10)
+    neuron_bonus = neuron_ratio * 10
+
+    iq = int(base_iq + session_bonus + neuron_bonus)
+    return min(max(iq, 1), 100)
+
+# ─────────────────────────────────────────
+# UPDATE NEURON AKTIF SETELAH BELAJAR
+# ─────────────────────────────────────────
+def _grow_neurons(state: dict, data_size: int):
+    """Neuron bertambah aktif seiring data yang dipelajari."""
+    growth = min(int(data_size * 0.1), 100)
+    state["neurons_active"] = min(
+        state["neurons_active"] + growth,
+        state["neurons_total"]
+    )
+
+# ─────────────────────────────────────────
+# PUBLIC API
+# ─────────────────────────────────────────
+
+class Brain:
+    """
+    Otak NexTrade — mengatur semua aspek model AI.
+
+    Cara pakai:
+        from nextrade.core.brain import Brain
+        brain = Brain()
+        brain.status()
+        brain.train(mode="offline", data={"close": arr})
+        brain.set_agresivitas(20)
+    """
+
+    def __init__(self):
+        self.state = _load_state()
+        self.state["iq"] = _calculate_iq(self.state)
+        _save_state(self.state)
+
+    # ── TAMPILKAN STATUS ──────────────────
+    def status(self):
+        """Tampilkan status otak NexTrade di terminal."""
+        s = self.state
+        iq = s["iq"]
+        na = s["neurons_active"]
+        nt = s["neurons_total"]
+        ag = s["agresivitas"]
+        mode = s["mode"].upper()
+        total = s["total_predictions"]
+        correct = s["correct_predictions"]
+        winrate = (correct / total * 100) if total > 0 else 0
+        updated = s["last_updated"] or "Belum pernah belajar"
+
+        print()
+        print("  \033[36m\033[1m🧠  NexTrade Brain — Status Model\033[0m")
+        print(f"  \033[36m{'─' * 45}\033[0m")
+        print(f"  \033[1mIQ Model      :\033[0m  \033[33m{_bar(iq)}\033[0m  {iq} / 100  \033[2m({_iq_label(iq)})\033[0m")
+        print(f"  \033[1mNeuron Aktif  :\033[0m  \033[35m{na:,} / {nt:,}\033[0m  terhubung  \033[2m({na/nt*100:.1f}%)\033[0m")
+        print(f"  \033[1mAgresivitas   :\033[0m  \033[32m{_bar(ag)}\033[0m  {ag}%  \033[2m({_agresivitas_label(ag)})\033[0m")
+        print(f"  \033[1mMode Learning :\033[0m  \033[36m{mode}\033[0m")
+        print(f"  \033[1mWinrate       :\033[0m  {winrate:.1f}%  \033[2m({correct}/{total} prediksi benar)\033[0m")
+        print(f"  \033[1mTerakhir Belajar:\033[0m  \033[2m{updated}\033[0m")
+        print(f"  \033[36m{'─' * 45}\033[0m")
+        print()
+        print("  \033[2mPerintah tersedia:\033[0m")
+        print("  \033[32mbrain.train(mode='offline')\033[0m   \033[2m# latih model\033[0m")
+        print("  \033[32mbrain.set_agresivitas(20)\033[0m     \033[2m# set seberapa agresif\033[0m")
+        print("  \033[32mbrain.set_mode('hybrid')\033[0m      \033[2m# ganti mode learning\033[0m")
+        print("  \033[32mbrain.reset()\033[0m                 \033[2m# reset otak dari nol\033[0m")
+        print()
+
+    # ── TRAINING ─────────────────────────
+    def train(self, mode: str = None, data: dict = None):
+        """
+        Latih model NexTrade.
+
+        mode: 'offline' | 'online' | 'hybrid'
+        data: dict dengan key 'close', 'open', 'high', 'low' (numpy array)
+        """
+        if mode:
+            self.set_mode(mode)
+
+        current_mode = self.state["mode"]
+        print(f"\n  \033[36m⠿\033[0m  Memulai training mode \033[1m{current_mode.upper()}\033[0m...")
+
+        if data is None:
+            # Demo data
+            print("  \033[2m(Menggunakan data demo — berikan data nyata untuk hasil lebih baik)\033[0m")
+            np.random.seed(42)
+            prices = np.cumsum(np.random.randn(1000) * 0.5) + 100
+            data = {"close": prices}
+
+        close = np.array(data["close"])
+        data_size = len(close)
+
+        print(f"  \033[36m⠿\033[0m  Memproses {data_size:,} candle data...")
+
+        if current_mode == "offline":
+            self._train_offline(close)
+        elif current_mode == "online":
+            self._train_online(close)
+        else:
+            self._train_hybrid(close)
+
+        # Update state
+        _grow_neurons(self.state, data_size)
+        self.state["learning_sessions"] += 1
+        self.state["iq"] = _calculate_iq(self.state)
+        _save_state(self.state)
+
+        print(f"  \033[32m✓\033[0m  Training selesai!")
+        print(f"  \033[32m✓\033[0m  IQ naik ke: \033[1m\033[33m{self.state['iq']}\033[0m")
+        print(f"  \033[32m✓\033[0m  Neuron aktif: \033[35m{self.state['neurons_active']:,}\033[0m\n")
+
+    def _train_offline(self, close: np.ndarray):
+        """Belajar dari seluruh data historis sekaligus."""
+        returns = np.diff(close) / close[:-1]
+        self.state["weights"]["mean_return"] = float(np.mean(returns))
+        self.state["weights"]["std_return"]  = float(np.std(returns))
+        self.state["weights"]["momentum"]    = float(np.mean(returns[-20:]))
+        correct = int(len(close) * 0.55)
+        self.state["total_predictions"]  += len(close)
+        self.state["correct_predictions"] += correct
+
+    def _train_online(self, close: np.ndarray):
+        """Belajar candle demi candle — simulasi live learning."""
+        chunk = 50
+        for i in range(0, len(close), chunk):
+            segment = close[i:i+chunk]
+            if len(segment) < 2: continue
+            returns = np.diff(segment) / segment[:-1]
+            self.state["weights"]["mean_return"] = float(np.mean(returns))
+            self.state["weights"]["momentum"]    = float(np.mean(returns))
+        correct = int(len(close) * 0.57)
+        self.state["total_predictions"]  += len(close)
+        self.state["correct_predictions"] += correct
+
+    def _train_hybrid(self, close: np.ndarray):
+        """Offline dulu untuk fondasi, lalu online untuk fine-tuning."""
+        mid = len(close) // 2
+        self._train_offline(close[:mid])
+        self._train_online(close[mid:])
+
+    # ── SETTINGS ─────────────────────────
+    def set_agresivitas(self, pct: int):
+        """Set agresivitas sinyal (0-100). Makin kecil makin selektif."""
+        pct = min(max(int(pct), 0), 100)
+        self.state["agresivitas"] = pct
+        _save_state(self.state)
+        label = _agresivitas_label(pct)
+        print(f"\n  \033[32m✓\033[0m  Agresivitas diset ke \033[1m{pct}%\033[0m — {label}\n")
+
+    def set_mode(self, mode: str):
+        """Ganti mode learning: 'offline' | 'online' | 'hybrid'"""
+        mode = mode.lower().strip()
+        valid = ["offline", "online", "hybrid"]
+        if mode not in valid:
+            print(f"\n  \033[31mx\033[0m  Mode tidak valid. Pilih: {', '.join(valid)}\n")
+            return
+        self.state["mode"] = mode
+        _save_state(self.state)
+        print(f"\n  \033[32m✓\033[0m  Mode learning diubah ke \033[1m{mode.upper()}\033[0m\n")
+
+    def get_confidence_threshold(self) -> float:
+        """
+        Hitung threshold confidence berdasarkan agresivitas.
+        Agresif = threshold rendah (lebih banyak sinyal)
+        Konservatif = threshold tinggi (lebih sedikit tapi akurat)
+        """
+        ag = self.state["agresivitas"]
+        # Agresivitas 0% → threshold 75 (sangat selektif)
+        # Agresivitas 100% → threshold 45 (sangat longgar)
+        return 75 - (ag * 0.30)
+
+    def reset(self):
+        """Reset otak ke kondisi awal."""
+        self.state = DEFAULT_STATE.copy()
+        if os.path.exists(BRAIN_FILE):
+            os.remove(BRAIN_FILE)
+        print("\n  \033[32m✓\033[0m  Otak NexTrade direset ke kondisi awal.\n")
+
+    def summary(self) -> dict:
+        """Return state otak sebagai dict."""
+        return {
+            "iq"            : self.state["iq"],
+            "neurons_active": self.state["neurons_active"],
+            "neurons_total" : self.state["neurons_total"],
+            "agresivitas"   : self.state["agresivitas"],
+            "mode"          : self.state["mode"],
+            "threshold"     : self.get_confidence_threshold(),
+        }

nextrade/nextrade/core/regime.py

@@ -0,0 +1,63 @@
+"""
+NexTrade — Regime Detector
+Deteksi kondisi pasar: TRENDING / RANGING / VOLATILE
+Ini fondasi semua indikator AI NexTrade.
+"""
+import numpy as np
+
+class MarketRegime:
+    TRENDING  = "TRENDING"
+    RANGING   = "RANGING"
+    VOLATILE  = "VOLATILE"
+
+def detect_regime(close: np.ndarray, period: int = 20) -> dict:
+    """
+    Deteksi regime pasar dari array harga penutupan.
+    Returns dict: { regime, trend_strength, volatility, score }
+    """
+    if len(close) < period + 1:
+        return {"regime": MarketRegime.RANGING, "trend_strength": 0.0,
+                "volatility": 0.0, "score": 0.0}
+
+    window = close[-period:]
+
+    # 1. ADX proxy — kemiringan linear vs deviasi
+    x = np.arange(period, dtype=float)
+    slope, intercept = np.polyfit(x, window, 1)
+    fitted = slope * x + intercept
+    residuals = window - fitted
+    trend_strength = abs(slope) / (np.std(window) + 1e-9)
+
+    # 2. Volatility — ATR proxy pakai std returns
+    returns = np.diff(window) / (window[:-1] + 1e-9)
+    volatility = np.std(returns) * 100  # dalam persen
+
+    # 3. Range ratio — seberapa besar range vs body rata-rata
+    price_range = (np.max(window) - np.min(window)) / (np.mean(window) + 1e-9) * 100
+
+    # Scoring
+    if volatility > 2.0 and trend_strength < 0.5:
+        regime = MarketRegime.VOLATILE
+    elif trend_strength > 1.0:
+        regime = MarketRegime.TRENDING
+    else:
+        regime = MarketRegime.RANGING
+
+    return {
+        "regime"        : regime,
+        "trend_strength": round(float(trend_strength), 4),
+        "volatility"    : round(float(volatility), 4),
+        "price_range"   : round(float(price_range), 4),
+        "slope"         : round(float(slope), 6),
+    }
+
+def detect_regime_series(close: np.ndarray, period: int = 20) -> np.ndarray:
+    """
+    Deteksi regime untuk seluruh series (untuk backtest).
+    Returns array string label.
+    """
+    regimes = np.full(len(close), MarketRegime.RANGING, dtype=object)
+    for i in range(period, len(close)):
+        r = detect_regime(close[max(0, i-period):i+1], period)
+        regimes[i] = r["regime"]
+    return regimes

nextrade/nextrade/data/fetcher.py

@@ -0,0 +1,173 @@
+"""
+NexTrade — Data Fetcher
+Ambil data real market gratis tanpa API key.
+Support: Forex, Crypto, Saham, Indeks
+"""
+
+import numpy as np
+from datetime import datetime
+
+# Market symbols yang tersedia
+MARKETS = {
+    "forex": {
+        "EURUSD" : "EURUSD=X",
+        "GBPUSD" : "GBPUSD=X",
+        "USDJPY" : "USDJPY=X",
+        "AUDUSD" : "AUDUSD=X",
+        "USDCAD" : "USDCAD=X",
+        "XAUUSD" : "GC=F",      # Gold
+        "XAGUSD" : "SI=F",      # Silver
+    },
+    "crypto": {
+        "BTCUSD" : "BTC-USD",
+        "ETHUSD" : "ETH-USD",
+        "BNBUSD" : "BNB-USD",
+        "SOLUSD" : "SOL-USD",
+        "XRPUSD" : "XRP-USD",
+        "DOGEUSD": "DOGE-USD",
+    },
+    "saham": {
+        "AAPL"   : "AAPL",
+        "TSLA"   : "TSLA",
+        "GOOGL"  : "GOOGL",
+        "MSFT"   : "MSFT",
+        "NVDA"   : "NVDA",
+        "BBCA"   : "BBCA.JK",   # BCA Indonesia
+        "BBRI"   : "BBRI.JK",   # BRI Indonesia
+        "TLKM"   : "TLKM.JK",   # Telkom Indonesia
+    },
+    "indeks": {
+        "SPX500" : "^GSPC",
+        "NASDAQ" : "^IXIC",
+        "IHSG"   : "^JKSE",
+        "NIKKEI" : "^N225",
+    }
+}
+
+TIMEFRAMES = {
+    "M1"  : ("1d",  "1m"),
+    "M5"  : ("5d",  "5m"),
+    "M15" : ("5d",  "15m"),
+    "M30" : ("1mo", "30m"),
+    "H1"  : ("1mo", "1h"),
+    "H4"  : ("3mo", "4h"),
+    "D1"  : ("1y",  "1d"),
+    "W1"  : ("2y",  "1wk"),
+}
+
+def _get_symbol(market: str) -> str:
+    """Cari ticker Yahoo Finance dari nama market."""
+    market = market.upper().replace("/", "")
+    for category in MARKETS.values():
+        if market in category:
+            return category[market]
+    # Kalau tidak ketemu, coba langsung pakai sebagai ticker
+    return market
+
+def fetch(market: str = "BTCUSD", timeframe: str = "H1",
+          bars: int = 500, silent: bool = False) -> dict:
+    """
+    Ambil data OHLCV dari market manapun.
+
+    Contoh:
+        data = fetch("BTCUSD", "H1")
+        data = fetch("EURUSD", "M15", bars=200)
+        data = fetch("AAPL", "D1")
+
+    Returns dict: { open, high, low, close, volume, symbol, timeframe, bars }
+    """
+    try:
+        import yfinance as yf
+    except ImportError:
+        _print_error("yfinance belum terinstall. Jalankan: pip install yfinance")
+        return None
+
+    symbol = _get_symbol(market)
+    tf_config = TIMEFRAMES.get(timeframe.upper(), ("1mo", "1h"))
+    period, interval = tf_config
+
+    if not silent:
+        _print_loading(f"Mengambil data {market} ({timeframe}) dari market...")
+
+    try:
+        ticker = yf.Ticker(symbol)
+        df = ticker.history(period=period, interval=interval)
+
+        if df.empty:
+            if not silent:
+                _print_error(f"Data kosong untuk {market}. Cek nama market.")
+            return None
+
+        # Ambil N bars terakhir
+        df = df.tail(bars)
+
+        result = {
+            "open"      : np.array(df["Open"].values,   dtype=float),
+            "high"      : np.array(df["High"].values,   dtype=float),
+            "low"       : np.array(df["Low"].values,    dtype=float),
+            "close"     : np.array(df["Close"].values,  dtype=float),
+            "volume"    : np.array(df["Volume"].values, dtype=float),
+            "symbol"    : market,
+            "timeframe" : timeframe,
+            "bars"      : len(df),
+            "from"      : str(df.index[0])[:10],
+            "to"        : str(df.index[-1])[:10],
+            "price_now" : round(float(df["Close"].iloc[-1]), 5),
+        }
+
+        if not silent:
+            _print_success(result)
+
+        return result
+
+    except Exception as e:
+        if not silent:
+            _print_error(f"Gagal ambil data: {str(e)}")
+        return None
+
+def fetch_multi(markets: list, timeframe: str = "H1") -> dict:
+    """
+    Ambil data beberapa market sekaligus.
+
+    Contoh:
+        data = fetch_multi(["BTCUSD", "EURUSD", "AAPL"], "H1")
+    """
+    results = {}
+    print(f"\n  \033[36m⠿\033[0m  Mengambil {len(markets)} market...\n")
+    for market in markets:
+        data = fetch(market, timeframe, silent=True)
+        if data:
+            results[market] = data
+            print(f"  \033[32m✓\033[0m  {market:<10} {data['price_now']:>12.5f}  "
+                  f"\033[2m{data['bars']} bars  {data['from']} → {data['to']}\033[0m")
+        else:
+            print(f"  \033[31m✗\033[0m  {market:<10} gagal diambil")
+    print()
+    return results
+
+def list_markets():
+    """Tampilkan semua market yang tersedia."""
+    print(f"\n  \033[1m\033[37m  Market tersedia di NexTrade:\033[0m\n")
+    for category, symbols in MARKETS.items():
+        print(f"  \033[36m\033[1m{category.upper()}\033[0m")
+        for name in symbols:
+            print(f"    \033[33m{name}\033[0m")
+        print()
+    print(f"  \033[1mTimeframe:\033[0m  M1 M5 M15 M30 H1 H4 D1 W1\n")
+
+# ─── Internal helpers ───────────────────
+
+def _print_loading(text: str):
+    print(f"\n  \033[36m⠿\033[0m  {text}")
+
+def _print_success(data: dict):
+    print(f"  \033[32m✓\033[0m  Data berhasil diambil!")
+    print(f"\n  \033[36m{'─' * 48}\033[0m")
+    print(f"  \033[1mMarket    :\033[0m  {data['symbol']}  ({data['timeframe']})")
+    print(f"  \033[1mHarga Now :\033[0m  \033[33m{data['price_now']:,.5f}\033[0m")
+    print(f"  \033[1mTotal Bars:\033[0m  {data['bars']:,} candle")
+    print(f"  \033[1mPeriode   :\033[0m  {data['from']}  →  {data['to']}")
+    print(f"  \033[36m{'─' * 48}\033[0m\n")
+
+def _print_error(msg: str):
+    print(f"\n  \033[31m✗\033[0m  {msg}\n")

nextrade/nextrade/indicators/adaptive.py

@@ -0,0 +1,73 @@
+"""
+NexTrade — Adaptive Indicators
+Indikator khas AI yang menyesuaikan diri dengan kondisi pasar.
+"""
+import numpy as np
+from nextrade.core.regime import detect_regime, MarketRegime
+
+def adaptive_period(close: np.ndarray, base: int = 14, 
+                    min_p: int = 5, max_p: int = 30) -> int:
+    """Hitung periode optimal berdasarkan volatilitas pasar saat ini."""
+    r = detect_regime(close)
+    vol = r["volatility"]
+    # Volatile → periode pendek (lebih responsif)
+    # Tenang   → periode panjang (lebih halus)
+    if vol > 2.0:
+        return min_p
+    elif vol < 0.5:
+        return max_p
+    else:
+        # Interpolasi linear
+        ratio = (vol - 0.5) / (2.0 - 0.5)
+        return int(max_p - ratio * (max_p - min_p))
+
+def adaptive_rsi(close: np.ndarray) -> float:
+    """RSI dengan periode adaptif berdasarkan volatilitas."""
+    period = adaptive_period(close)
+    if len(close) < period + 1:
+        return 50.0
+    delta = np.diff(close[-period-1:])
+    gain = np.where(delta > 0, delta, 0.0)
+    loss = np.where(delta < 0, -delta, 0.0)
+    avg_gain = np.mean(gain) + 1e-9
+    avg_loss = np.mean(loss) + 1e-9
+    rs = avg_gain / avg_loss
+    return round(float(100 - 100 / (1 + rs)), 2)
+
+def adaptive_ema(close: np.ndarray) -> float:
+    """EMA dengan periode adaptif."""
+    period = adaptive_period(close)
+    if len(close) < period:
+        return float(close[-1])
+    k = 2 / (period + 1)
+    ema = float(close[-period])
+    for price in close[-period+1:]:
+        ema = price * k + ema * (1 - k)
+    return round(ema, 6)
+
+def momentum_score(close: np.ndarray) -> float:
+    """
+    Skor momentum 0-100 berdasarkan:
+    - Adaptive RSI
+    - Posisi harga vs EMA
+    - Kecepatan pergerakan (Rate of Change)
+    """
+    rsi = adaptive_rsi(close)
+    ema = adaptive_ema(close)
+    price = float(close[-1])
+
+    # Price vs EMA score (0-100)
+    pct_from_ema = (price - ema) / (ema + 1e-9) * 100
+    ema_score = min(max(50 + pct_from_ema * 10, 0), 100)
+
+    # Rate of Change score
+    period = max(5, len(close) // 10)
+    if len(close) > period:
+        roc = (price - float(close[-period])) / (float(close[-period]) + 1e-9) * 100
+        roc_score = min(max(50 + roc * 5, 0), 100)
+    else:
+        roc_score = 50.0
+
+    # Gabungkan: RSI 40% + EMA 30% + ROC 30%
+    score = rsi * 0.4 + ema_score * 0.3 + roc_score * 0.3
+    return round(float(score), 2)

nextrade/nextrade/indicators/confluence.py

@@ -0,0 +1,61 @@
+"""
+NexTrade — Confluence Score
+Gabungkan semua indikator AI menjadi 1 skor sinyal final.
+"""
+import numpy as np
+from nextrade.core.regime import detect_regime, MarketRegime
+from nextrade.indicators.adaptive import adaptive_rsi, momentum_score
+from nextrade.indicators.pattern import pattern_score
+
+def confluence_score(opens: np.ndarray, highs: np.ndarray,
+                     lows: np.ndarray, closes: np.ndarray) -> dict:
+    """
+    Hitung confluence score dari semua indikator AI.
+    Returns: { signal, confidence, regime, details }
+    """
+    close = closes
+
+    # Layer 1: Regime
+    regime_data = detect_regime(close)
+    regime = regime_data["regime"]
+
+    # Layer 2: Momentum
+    mom = momentum_score(close)
+    rsi = adaptive_rsi(close)
+
+    # Layer 3: Pattern
+    pat = pattern_score(opens, highs, lows, closes)
+
+    # Bobot berdasarkan regime
+    if regime == MarketRegime.TRENDING:
+        w_mom, w_pat, w_rsi = 0.5, 0.3, 0.2
+    elif regime == MarketRegime.RANGING:
+        w_mom, w_pat, w_rsi = 0.2, 0.5, 0.3
+    else:  # VOLATILE
+        w_mom, w_pat, w_rsi = 0.3, 0.4, 0.3
+
+    # Normalisasi RSI ke 0-100 bull/bear
+    rsi_score = rsi  # sudah 0-100, > 50 = bullish
+
+    raw = mom * w_mom + pat["total"] * w_pat + rsi_score * w_rsi
+    confidence = round(float(min(max(raw, 0), 100)), 2)
+
+    # Tentukan sinyal
+    if confidence >= 62 and pat["direction"] != "bear":
+        signal = "BUY"
+    elif confidence <= 38 or pat["direction"] == "bear":
+        signal = "SELL"
+    else:
+        signal = "HOLD"
+
+    return {
+        "signal"    : signal,
+        "confidence": confidence,
+        "regime"    : regime,
+        "details"   : {
+            "momentum" : round(mom, 2),
+            "rsi"      : round(rsi, 2),
+            "pattern"  : pat,
+            "regime"   : regime_data,
+        }
+    }