Initial commit: Trading Bot v1.0 - Paper Trading mit KI

.env.example

@@ -0,0 +1,15 @@
+# KI Provider: "anthropic", "openai" oder "ollama"
+AI_PROVIDER=anthropic
+AI_MODEL_NAME=
+
+# Supabase
+SUPABASE_URL=https://your-project.supabase.co
+SUPABASE_KEY=your-anon-key
+
+# API Keys (je nach Provider)
+ANTHROPIC_API_KEY=
+OPENAI_API_KEY=
+OLLAMA_BASE_URL=http://localhost:11434/api/generate
+
+# Logging
+LOG_LEVEL=INFO

.gitignore

@@ -0,0 +1,8 @@
+.env
+__pycache__/
+*.pyc
+.venv/
+venv/
+*.egg-info/
+dist/
+build/

Procfile

@@ -0,0 +1 @@
+web: uvicorn app:app --host 0.0.0.0 --port 7860

README.md

@@ -0,0 +1,107 @@
+# Autonomer Krypto-Trading-Bot
+
+Ein zweistufiger autonomer Krypto-Trading-Bot:
+
+1. **Screener** (Top 100 Coins, regelbasiert, kein KI)
+2. **KI-Entscheidung** (Entry/Exit durch LLM)
+3. **Paper-Trading** (Supabase, kein echtes Geld)
+4. **24/7** auf Hugging Face Spaces, getriggert von Cron-Job.org
+
+## Tech Stack
+
+| Komponente | Dienst |
+|---|---|
+| Hosting | Hugging Face Spaces |
+| Trigger | Cron-Job.org (alle 5 Min) |
+| Marktdaten | Binance Public API |
+| KI | Anthropic / OpenAI / Ollama (konfigurierbar) |
+| Datenbank | Supabase (PostgreSQL) |
+
+## Setup
+
+### 1. Lokale Entwicklung
+
+```bash
+python -m venv venv
+source venv/bin/activate  # oder venv\Scripts\activate auf Windows
+pip install -r requirements.txt
+```
+
+### 2. Umgebungsvariablen
+
+Kopiere `.env.example` zu `.env` und fülle die Werte:
+
+```env
+AI_PROVIDER=anthropic
+AI_MODEL_NAME=claude-sonnet-4-20250514
+
+SUPABASE_URL=https://your-project.supabase.co
+SUPABASE_KEY=your-anon-key
+
+ANTHROPIC_API_KEY=sk-ant-...
+```
+
+### 3. Supabase Schema
+
+Führe `schema.sql` im Supabase SQL Editor aus.
+
+### 4. Lokale Tests
+
+```bash
+python run_screener_test.py   # Phase 1: Screener
+python run_ai_test.py          # Phase 2: KI
+python run_db_test.py          # Phase 3: DB
+python run_exit_test.py        # Phase 4: Exit
+```
+
+### 5. Hugging Face Deployment
+
+1. GitHub Repo erstellen und pushen
+2. Hugging Face Space erstellen (Free Tier)
+3. GitHub Repo mit Space verknüpfen
+4. Secrets eintragen:
+   - `ANTHROPIC_API_KEY`
+   - `SUPABASE_URL`
+   - `SUPABASE_KEY`
+   - `AI_PROVIDER`
+   - `AI_MODEL_NAME`
+5. Cron-Job.org einrichten: `POST https://<user>-trading-bot.hf.space/scan` alle 5 Min
+
+## KI Provider wechseln
+
+Der Bot unterstützt drei KI-Provider:
+
+```env
+# Anthropic (Standard)
+AI_PROVIDER=anthropic
+AI_MODEL_NAME=claude-sonnet-4-20250514
+
+# OpenAI
+AI_PROVIDER=openai
+AI_MODEL_NAME=gpt-4o-mini
+
+# Ollama (lokal)
+AI_PROVIDER=ollama
+AI_MODEL_NAME=llama3.2
+```
+
+## API Endpoints
+
+| Endpoint | Methode | Beschreibung |
+|---|---|---|
+| `/` | GET | Health Check |
+| `/scan` | POST | Bot-Zyklus ausführen |
+| `/positions` | GET | Offene Positionen |
+| `/status` | GET | Bot Status |
+
+## Phasen
+
+- [x] Phase 1: Lokaler Screener-Test
+- [x] Phase 2: KI lokal integrieren
+- [x] Phase 3: Supabase anbinden
+- [x] Phase 4: Exit-Logik integrieren
+- [x] Phase 5: Hugging Face Deployment
+
+## Lizenz
+
+Privat — nicht für Produktion ohne Tests.

ai/__init__.py

@@ -0,0 +1 @@
+"""ai — KI-Entscheidungen für Entry und Exit."""

ai/entry_prompt.py

@@ -0,0 +1,165 @@
+"""
+entry_prompt.py — KI-Prompt für Kaufentscheidung.
+
+Baut den Prompt aus den Screener-Daten und ruft die KI auf.
+Parst die Antwort als JSON.
+"""
+
+import logging
+from datetime import datetime
+
+from ai.provider import get_provider, parse_json_response, AIProviderError
+
+logger = logging.getLogger(__name__)
+
+# ── System Prompt ──
+SYSTEM_PROMPT = """Du bist die analytische Entscheidungs-Engine für einen autonomen
+Trading-Agenten. Du bewertest ausschließlich die gelieferten Daten —
+keine Meinungen, keine Halluzinationen.
+Wenn das Setup nicht eindeutig ist, entscheidest du dich für SKIP.
+SKIP ist immer die sichere Wahl.
+
+RISIKOREGEL (nicht verhandelbar):
+- Stop-Loss: 1.5x bis 2.5x ATR unterhalb des Entry-Preises.
+- Take-Profit 1: mindestens 2.0x den Stop-Loss-Abstand (R:R ≥ 1:2).
+- Take-Profit 2: mindestens 3.5x den Stop-Loss-Abstand (R:R ≥ 1:3.5).
+- Wenn diese Levels durch aktuelle Widerstände unrealistisch sind → SKIP.
+- Bei confidence < 7 ist die Entscheidung automatisch SKIP."""
+
+
+def build_entry_prompt(
+    symbol: str,
+    price: float,
+    position_size_usd: float,
+    ohlcv_data: list,
+    indicators: dict,
+    screener_reason: str,
+    btc_context: dict
+) -> tuple[str, str]:
+    """
+    Baut den Entry-Prompt.
+
+    Args:
+        symbol: Coin Symbol
+        price: Aktueller Preis
+        position_size_usd: Berechnete Positionsgröße
+        ohlcv_data: Letzte 10 OHLCV-Kerzen
+        indicators: Dict mit RSI, MACD, EMA, Volume, ATR
+        screener_reason: Begründung des Screener (z.B. "Volume_Spike_2.3x, MACD_Cross")
+        btc_context: Dict mit btc_4h_pct, btc_above_ema50
+
+    Returns:
+        Tuple von (system_prompt, user_prompt)
+    """
+    # OHLCV Tabelle als Text
+    ohlcv_table = "Zeit | Open | High | Low | Close | Volume\n"
+    ohlcv_table += "-" * 50 + "\n"
+    for kline in ohlcv_data[-10:]:
+        from datetime import datetime
+        dt = datetime.fromtimestamp(kline[0] / 1000).strftime("%H:%M")
+        ohlcv_table += (
+            f"{dt} | {kline[1]:.4f} | {kline[2]:.4f} | "
+            f"{kline[3]:.4f} | {kline[4]:.4f} | {kline[5]:.0f}\n"
+        )
+
+    user_prompt = f"""ASSET: {symbol} | TIMEFRAME: 15min
+AKTUELLER PREIS: {price} USD
+BERECHNETE POSITIONSGRÖSSE: {position_size_usd} USD
+
+TECHNISCHE DATEN (Letzte 10 Kerzen, OHLCV):
+{ohlcv_table}
+
+INDIKATOREN:
+- RSI (14): {indicators.get('rsi', 'N/A')}
+- MACD: Line={indicators.get('macd', {}).get('line', 'N/A')}, Signal={indicators.get('macd', {}).get('signal', 'N/A')}, Histogram={indicators.get('macd', {}).get('histogram', 'N/A')}
+- EMA: 9={indicators.get('ema9', 'N/A')}, 21={indicators.get('ema21', 'N/A')}, 50={indicators.get('ema50', 'N/A')}
+- Volume Ratio (vs. 20-Candle-Avg): {indicators.get('volume_ratio_20', 'N/A')}x
+- Volume Ratio (vs. 5-Candle-Avg): {indicators.get('volume_ratio_5', 'N/A')}x
+- ATR (14, 15min): {indicators.get('atr', 'N/A')} USD
+
+SCREENER-BEGRÜNDUNG:
+{screener_reason}
+
+MARKTKONTEXT:
+- BTC 4h Change: {btc_context.get('btc_4h_pct', 'N/A')}%
+- BTC über EMA 50 (4h): {btc_context.get('btc_above_ema50', 'N/A')}
+
+Antworte AUSSCHLIESSLICH in diesem JSON-Format, kein Text davor/danach:
+{{
+  "decision": "BUY" | "SKIP",
+  "confidence": 1-10,
+  "entry_price": float,
+  "stop_loss": float,
+  "take_profit_1": float,
+  "take_profit_2": float,
+  "risk_reward_ratio": float,
+  "learning_tags": ["string"],
+  "reason": "Maximal 2 Sätze."
+}}
+
+Mögliche learning_tags (Array, mehrere erlaubt):
+"Volume_Breakout", "MACD_Cross", "RSI_Reversal",
+"RSI_Momentum", "Trend_Continuation", "EMA_Alignment", "Mixed_Signal\""""
+
+    return SYSTEM_PROMPT, user_prompt
+
+
+def get_entry_decision(
+    symbol: str,
+    price: float,
+    position_size_usd: float,
+    ohlcv_data: list,
+    indicators: dict,
+    screener_reason: str,
+    btc_context: dict
+) -> dict:
+    """
+    Ruft KI für Entry-Entscheidung auf.
+
+    Args:
+        symbol: Coin Symbol
+        price: Aktueller Preis
+        position_size_usd: Berechnete Positionsgröße
+        ohlcv_data: OHLCV-Kerzen
+        indicators: Indikatoren-Dict
+        screener_reason: Screener-Begründung
+        btc_context: BTC-Kontext
+
+    Returns:
+        Dict mit decision, confidence, entry_price, stop_loss, etc.
+        Bei Fehler: {"decision": "SKIP", "reason": "..."}
+    """
+    system_prompt, user_prompt = build_entry_prompt(
+        symbol, price, position_size_usd, ohlcv_data,
+        indicators, screener_reason, btc_context
+    )
+
+    try:
+        provider = get_provider()
+        response = provider.generate(system_prompt, user_prompt)
+        result = parse_json_response(response)
+
+        # Normalisieren
+        result["decision"] = result.get("decision", "SKIP").upper()
+        result["confidence"] = int(result.get("confidence", 0))
+
+        logger.info(
+            f"KI Entry {symbol}: {result['decision']} "
+            f"(Confidence: {result['confidence']})"
+        )
+        return result
+
+    except AIProviderError as e:
+        logger.error(f"KI Entry Fehler für {symbol}: {e}")
+        return {
+            "decision": "SKIP",
+            "confidence": 0,
+            "reason": f"KI_ERROR: {e}"
+        }
+    except ValueError as e:
+        logger.error(f"KI Entry JSON-Fehler für {symbol}: {e}")
+        return {
+            "decision": "SKIP",
+            "confidence": 0,
+            "reason": f"JSON_PARSE_ERROR: {e}"
+        }

ai/exit_prompt.py

@@ -0,0 +1,162 @@
+"""
+exit_prompt.py — KI-Prompt für Verkaufsentscheidung.
+
+Wird nur aufgerufen wenn der Sell-Screener Score 2-3 hat (ambivalent).
+"""
+
+import logging
+from datetime import datetime
+
+from ai.provider import get_provider, parse_json_response, AIProviderError
+
+logger = logging.getLogger(__name__)
+
+# ── System Prompt ──
+SYSTEM_PROMPT = """Du bist die analytische Exit-Engine für einen autonomen Trading-Agenten.
+Du entscheidest ob eine offene Position geschlossen werden soll.
+Ein technischer Screener hat ambivalente Warnsignale gesendet.
+
+SICHERHEITSREGEL (nicht verhandelbar):
+- Bei confidence < 6 ist die Entscheidung automatisch SELL.
+  Im Zweifel schützt man Kapital.
+- new_trailing_stop_usd darf NIEMALS über dem aktuellen Preis liegen
+  und NIEMALS schlechter als der aktuell gesetzte Trailing-Stop sein."""
+
+
+def build_exit_prompt(
+    symbol: str,
+    entry_price: float,
+    current_price: float,
+    pnl_percent: float,
+    duration_minutes: int,
+    initial_stop: float,
+    current_trailing_stop: float | None,
+    tp1_hit: bool,
+    hold_count: int,
+    ohlcv_data: list,
+    indicators: dict,
+    sell_reason: str,
+    btc_context: dict
+) -> tuple[str, str]:
+    """
+    Baut den Exit-Prompt.
+
+    Returns:
+        Tuple von (system_prompt, user_prompt)
+    """
+    # OHLCV Tabelle
+    ohlcv_table = "Zeit | Open | High | Low | Close | Volume\n"
+    ohlcv_table += "-" * 50 + "\n"
+    for kline in ohlcv_data[-10:]:
+        dt = datetime.fromtimestamp(kline[0] / 1000).strftime("%H:%M")
+        ohlcv_table += (
+            f"{dt} | {kline[1]:.4f} | {kline[2]:.4f} | "
+            f"{kline[3]:.4f} | {kline[4]:.4f} | {kline[5]:.0f}\n"
+        )
+
+    tp1_status = "Ja" if tp1_hit else "Nein"
+    trailing_str = f"{current_trailing_stop:.4f}" if current_trailing_stop else "Nicht aktiv"
+
+    user_prompt = f"""POSITION:
+- Asset: {symbol}
+- Entry-Preis: {entry_price} USD
+- Aktueller Preis: {current_price} USD
+- Aktueller P&L: {pnl_percent}%
+- Haltedauer: {duration_minutes} Minuten
+- Initialer Stop-Loss: {initial_stop} USD
+- Aktueller Trailing-Stop: {trailing_str} USD
+- TP1 bereits erreicht: {tp1_status}
+- HOLD-Entscheidungen in Folge: {hold_count}
+
+TECHNISCHE DATEN (Letzte 10 Kerzen, 15min):
+{ohlcv_table}
+
+INDIKATOREN:
+- RSI (14): {indicators.get('rsi', 'N/A')}
+- MACD: Line={indicators.get('macd', {}).get('line', 'N/A')}, Signal={indicators.get('macd', {}).get('signal', 'N/A')}, Histogram={indicators.get('macd', {}).get('histogram', 'N/A')}
+- EMA 9: {indicators.get('ema9', 'N/A')} | Preis vs. EMA 9: {'über' if current_price > indicators.get('ema9', 0) else 'unter'}
+- Volume Ratio (vs. 20-Candle-Avg): {indicators.get('volume_ratio_20', 'N/A')}x
+- ATR (14, 15min): {indicators.get('atr', 'N/A')} USD
+
+SCREENER-WARNUNG:
+{sell_reason}
+
+MARKTKONTEXT:
+- BTC 15min Change: {btc_context.get('btc_15min_pct', 'N/A')}%
+- BTC 1h Change: {btc_context.get('btc_1h_pct', 'N/A')}%
+
+Antworte AUSSCHLIESSLICH in diesem JSON-Format, kein Text davor/danach:
+{{
+  "decision": "SELL" | "HOLD",
+  "confidence": 1-10,
+  "new_trailing_stop_usd": float | null,
+  "learning_tags": ["string"],
+  "reason": "Maximal 2 Sätze."
+}}
+
+Mögliche learning_tags:
+"Hold_Normal_Pullback", "Hold_Trend_Intact",
+"Sell_Momentum_Loss", "Sell_MACD_Reversal",
+"Sell_Volume_Collapse", "Sell_Mixed_Signals", "Sell_Overbought\""""
+
+    return SYSTEM_PROMPT, user_prompt
+
+
+def get_exit_decision(
+    symbol: str,
+    entry_price: float,
+    current_price: float,
+    pnl_percent: float,
+    duration_minutes: int,
+    initial_stop: float,
+    current_trailing_stop: float | None,
+    tp1_hit: bool,
+    hold_count: int,
+    ohlcv_data: list,
+    indicators: dict,
+    sell_reason: str,
+    btc_context: dict
+) -> dict:
+    """
+    Ruft KI für Exit-Entscheidung auf.
+
+    Returns:
+        Dict mit decision, confidence, new_trailing_stop_usd, etc.
+        Bei Fehler: {"decision": "HOLD", "reason": "..."}
+    """
+    system_prompt, user_prompt = build_exit_prompt(
+        symbol, entry_price, current_price, pnl_percent,
+        duration_minutes, initial_stop, current_trailing_stop,
+        tp1_hit, hold_count, ohlcv_data, indicators,
+        sell_reason, btc_context
+    )
+
+    try:
+        provider = get_provider()
+        response = provider.generate(system_prompt, user_prompt)
+        result = parse_json_response(response)
+
+        # Normalisieren
+        result["decision"] = result.get("decision", "HOLD").upper()
+        result["confidence"] = int(result.get("confidence", 0))
+
+        logger.info(
+            f"KI Exit {symbol}: {result['decision']} "
+            f"(Confidence: {result['confidence']})"
+        )
+        return result
+
+    except AIProviderError as e:
+        logger.error(f"KI Exit Fehler für {symbol}: {e}")
+        return {
+            "decision": "HOLD",
+            "confidence": 0,
+            "reason": f"KI_ERROR: {e}"
+        }
+    except ValueError as e:
+        logger.error(f"KI Exit JSON-Fehler für {symbol}: {e}")
+        return {
+            "decision": "HOLD",
+            "confidence": 0,
+            "reason": f"JSON_PARSE_ERROR: {e}"
+        }

ai/provider.py

@@ -0,0 +1,196 @@
+"""
+provider.py — KI Provider-Abstraktionsschicht.
+
+Ermöglicht einfachen Wechsel zwischen Anthropic, OpenAI und Ollama.
+Kein Code-Änderung nötig — nur Umgebungsvariablen ändern.
+
+Usage:
+    from ai.provider import get_provider
+    provider = get_provider()
+    response = provider.generate(system_prompt, user_prompt)
+"""
+
+import os
+import json
+import logging
+import requests
+
+import config
+
+logger = logging.getLogger(__name__)
+
+
+class AIProvider:
+    """Basisklasse für KI-Provider."""
+
+    def generate(self, system_prompt: str, user_prompt: str) -> str:
+        """
+        Sendet Prompt an KI und gibt Antwort zurück.
+
+        Args:
+            system_prompt: System-Anweisung
+            user_prompt: User-Eingabe
+
+        Returns:
+            Antwort-Text der KI
+
+        Raises:
+            AIProviderError: Bei Fehlern
+        """
+        raise NotImplementedError
+
+
+class AnthropicProvider(AIProvider):
+    """Anthropic Claude API Provider (inkl. OpenRouter Kompatibilitaet)."""
+
+    def __init__(self):
+        import anthropic
+
+        api_key = os.getenv("ANTHROPIC_API_KEY")
+        if not api_key:
+            raise AIProviderError("ANTHROPIC_API_KEY nicht gesetzt")
+
+        # OpenRouter unterstuetzt Anthropic-kompatible APIs
+        base_url = os.getenv("ANTHROPIC_BASE_URL", "")
+
+        if base_url:
+            self.client = anthropic.Anthropic(api_key=api_key, base_url=base_url)
+        else:
+            self.client = anthropic.Anthropic(api_key=api_key)
+
+        self.model = config.AI_MODEL_NAME or "claude-sonnet-4-20250514"
+
+    def generate(self, system_prompt: str, user_prompt: str) -> str:
+        try:
+            response = self.client.messages.create(
+                model=self.model,
+                max_tokens=1024,
+                system=system_prompt,
+                messages=[{"role": "user", "content": user_prompt}]
+            )
+            return response.content[0].text
+        except Exception as e:
+            raise AIProviderError(f"Anthropic API Fehler: {e}") from e
+
+
+class OpenAIProvider(AIProvider):
+    """OpenAI API Provider."""
+
+    def __init__(self):
+        import openai
+
+        api_key = os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            raise AIProviderError("OPENAI_API_KEY nicht gesetzt")
+
+        self.client = openai.OpenAI(api_key=api_key)
+        self.model = config.AI_MODEL_NAME or "gpt-4o-mini"
+
+    def generate(self, system_prompt: str, user_prompt: str) -> str:
+        try:
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                max_tokens=1024
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            raise AIProviderError(f"OpenAI API Fehler: {e}") from e
+
+
+class OllamaProvider(AIProvider):
+    """Lokaler Ollama Provider (für lokales Testen ohne API-Kosten)."""
+
+    def __init__(self):
+        self.base_url = os.getenv("OLLAMA_BASE_URL", "http://localhost:11434")
+        self.model = config.AI_MODEL_NAME or "llama3.2"
+
+    def generate(self, system_prompt: str, user_prompt: str) -> str:
+        url = f"{self.base_url}/api/generate"
+        full_prompt = f"{system_prompt}\n\n{user_prompt}"
+
+        try:
+            response = requests.post(url, json={
+                "model": self.model,
+                "prompt": full_prompt,
+                "stream": False
+            }, timeout=30)
+            response.raise_for_status()
+            return response.json().get("response", "")
+        except Exception as e:
+            raise AIProviderError(f"Ollama API Fehler: {e}") from e
+
+
+class AIProviderError(Exception):
+    """Fehler bei KI-Provider."""
+    pass
+
+
+def get_provider() -> AIProvider:
+    """
+    Factory-Funktion: Erstellt den konfigurierten KI-Provider.
+
+    Returns:
+        AIProvider Instanz
+
+    Raises:
+        AIProviderError: Bei unbekanntem Provider
+    """
+    provider_type = config.AI_PROVIDER.lower()
+
+    if provider_type == "anthropic":
+        return AnthropicProvider()
+    elif provider_type == "openai":
+        return OpenAIProvider()
+    elif provider_type == "ollama":
+        return OllamaProvider()
+    else:
+        raise AIProviderError(
+            f"Unbekannter AI_PROVIDER: '{provider_type}'. "
+            f"Erlaubt: 'anthropic', 'openai', 'ollama'"
+        )
+
+
+def parse_json_response(response_text: str) -> dict:
+    """
+    Extrahiert JSON aus KI-Antwort.
+
+    KI manchmal Text vor/nach dem JSON. Diese Funktion
+    findet und parst das JSON robust.
+
+    Args:
+        response_text: Rohe KI-Antwort
+
+    Returns:
+        Geparstes Dict
+
+    Raises:
+        ValueError: Wenn kein gültiges JSON gefunden
+    """
+    # Versuch 1: Direkt parsen
+    try:
+        return json.loads(response_text.strip())
+    except json.JSONDecodeError:
+        pass
+
+    # Versuch 2: JSON in Code-Block finden (```json ... ```)
+    import re
+    code_block = re.search(r'```(?:json)?\s*\n?(.*?)\n?```', response_text, re.DOTALL)
+    if code_block:
+        try:
+            return json.loads(code_block.group(1))
+        except json.JSONDecodeError:
+            pass
+
+    # Versuch 3: Erstes { ... } finden
+    json_match = re.search(r'\{.*\}', response_text, re.DOTALL)
+    if json_match:
+        try:
+            return json.loads(json_match.group(0))
+        except json.JSONDecodeError:
+            pass
+
+    raise ValueError(f"Kein gültiges JSON in KI-Antwort gefunden: {response_text[:200]}")

ai/validator.py

@@ -0,0 +1,160 @@
+"""
+validator.py — Backend-Validation für KI-Entscheidungen.
+
+Wird NACH der KI, VOR dem Paper-Trade ausgeführt.
+Härtet Filter — auch wenn KI "BUY" sagt, kann der Validator blockieren.
+"""
+
+import logging
+from datetime import datetime, timezone
+
+import config
+
+logger = logging.getLogger(__name__)
+
+
+def validate_entry_decision(decision: dict, current_price: float) -> tuple[bool, str]:
+    """
+    Validiert KI Entry-Entscheidung.
+
+    Args:
+        decision: KI-Output Dict
+        current_price: Aktueller Preis
+
+    Returns:
+        Tuple von (is_valid, reason)
+    """
+    # Entscheidung muss BUY sein
+    if decision.get("decision") != "BUY":
+        return False, f"NOT_BUY: {decision.get('decision')}"
+
+    # Confidence Check
+    confidence = decision.get("confidence", 0)
+    if confidence < config.ENTRY_MIN_CONFIDENCE:
+        return False, f"CONFIDENCE_TOO_LOW: {confidence} < {config.ENTRY_MIN_CONFIDENCE}"
+
+    # Stop Loss muss unter Entry sein
+    entry_price = decision.get("entry_price", current_price)
+    stop_loss = decision.get("stop_loss", 0)
+
+    if stop_loss <= 0:
+        return False, "INVALID_STOP_LOSS: Kein Stop Loss gesetzt"
+
+    if stop_loss >= entry_price:
+        return False, f"STOP_ABOVE_ENTRY: SL={stop_loss} >= Entry={entry_price}"
+
+    # Risk-Reward Check
+    sl_distance = entry_price - stop_loss
+    tp1 = decision.get("take_profit_0", 0)
+    if tp1 <= 0:
+        tp1 = decision.get("take_profit_1", 0)
+    tp1_distance = tp1 - entry_price
+
+    if sl_distance <= 0:
+        return False, "INVALID_SL_DISTANCE"
+
+    rr_ratio = tp1_distance / sl_distance
+    if rr_ratio < config.ENTRY_MIN_RR:
+        return False, f"RR_TOO_LOW: {rr_ratio:.2f} < {config.ENTRY_MIN_RR}"
+
+    # Position Size Check
+    position_size = decision.get("position_size_usd", 0)
+    if position_size <= 0:
+        return False, "INVALID_POSITION_SIZE"
+
+    max_size = config.PORTFOLIO_VALUE_USD * 0.10
+    if position_size > max_size:
+        return False, f"POSITION_TOO_LARGE: {position_size} > {max_size}"
+
+    logger.info(
+        f"Entry validiert: {decision.get('symbol', '?')} | "
+        f"Confidence: {confidence} | R:R: {rr_ratio:.2f}"
+    )
+    return True, "OK"
+
+
+def validate_exit_decision(
+    decision: dict,
+    current_price: float,
+    current_trailing_stop: float | None,
+    hold_count: int
+) -> str:
+    """
+    Validiert KI Exit-Entscheidung.
+
+    Args:
+        decision: KI-Output Dict
+        current_price: Aktueller Preis
+        current_trailing_stop: Aktueller Trailing Stop (oder None)
+        hold_count: Anzahl HOLD-Entscheidungen in Folge
+
+    Returns:
+        "SELL" oder "HOLD"
+    """
+    # Zwangsverkauf nach 3x HOLD
+    if hold_count >= config.MAX_HOLD_COUNT:
+        logger.info(f"Exit: Zwangsverkauf nach {hold_count}x HOLD")
+        return "SELL"
+
+    # Confidence zu niedrig → SELL
+    confidence = decision.get("confidence", 0)
+    if confidence < config.EXIT_MIN_CONFIDENCE:
+        logger.info(f"Exit: Confidence {confidence} < {config.EXIT_MIN_CONFIDENCE} → SELL")
+        return "SELL"
+
+    # Trailing Stop Validierung
+    new_stop = decision.get("new_trailing_stop_usd")
+    if new_stop is not None:
+        # Neuer Stop darf nicht über aktuellem Preis liegen
+        if new_stop >= current_price:
+            logger.warning(
+                f"Exit: Neuer Trailing Stop {new_stop} >= Preis {current_price} → ignoriert"
+            )
+            decision["new_trailing_stop_usd"] = None
+
+        # Neuer Stop darf nicht schlechter als aktueller
+        elif current_trailing_stop and new_stop < current_trailing_stop:
+            logger.warning(
+                f"Exit: Neuer Trailing Stop {new_stop} < aktueller {current_trailing_stop} → ignoriert"
+            )
+            decision["new_trailing_stop_usd"] = None
+
+    return decision.get("decision", "HOLD")
+
+
+def calculate_position_size(entry_price: float, stop_loss: float) -> float:
+    """
+    Berechnet Positionsgröße basierend auf Risikoprozentsatz.
+
+    Formel:
+        risk_amount = portfolio_value * (risk_per_trade_pct / 100)
+        position_size = risk_amount / sl_distance
+        capped = min(position_size * entry_price, portfolio_value * 0.10)
+
+    Args:
+        entry_price: Einstiegspreis
+        stop_loss: Stop Loss Preis
+
+    Returns:
+        Positionsgröße in USD
+    """
+    if entry_price <= 0 or stop_loss <= 0:
+        return 0.0
+
+    sl_distance = entry_price - stop_loss
+    if sl_distance <= 0:
+        return 0.0
+
+    risk_amount = config.PORTFOLIO_VALUE_USD * (config.RISK_PER_TRADE_PCT / 100)
+    position_size = risk_amount / sl_distance
+    position_value = position_size * entry_price
+
+    # Cap bei 10% des Portfolios
+    max_value = config.PORTFOLIO_VALUE_USD * 0.10
+    final_value = min(position_value, max_value)
+
+    logger.info(
+        f"Positionsgröße: ${final_value:.2f} "
+        f"(Risk: ${risk_amount:.2f}, SL Distance: ${sl_distance:.4f})"
+    )
+    return round(final_value, 2)

app.py

@@ -0,0 +1,266 @@
+"""
+app.py — FastAPI Hauptapp für Hugging Face Space.
+
+Entry Point für den Bot. Hugging Face ruft diese Datei auf.
+Cron-Job.org triggert POST /scan alle 5 Minuten.
+"""
+
+import logging
+import sys
+import os
+import traceback
+from datetime import datetime, timezone
+
+# Sicherstellen dass das Projekt-Verzeichnis im sys.path ist
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from fastapi import FastAPI
+from fastapi.responses import JSONResponse
+
+from screener.market_gate import market_gate_check
+from data.universe import get_top100_universe
+from screener.screener import run_screener
+from ai.entry_prompt import get_entry_decision
+from ai.validator import validate_entry_decision, calculate_position_size
+from positions.manager import open_position, close_position, close_partial_position, get_all_open_positions
+from positions.exit_logic import process_exit
+from db.supabase_client import (
+    log_scan, log_btc_price, get_open_positions,
+    get_open_position_count, is_configured as db_configured
+)
+from data.binance import get_current_price
+
+# Logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(title="Trading Bot", version="1.0.0")
+
+
+@app.get("/")
+def health_check():
+    """Health Check — schläft HF Space nicht ein."""
+    return {
+        "status": "healthy",
+        "service": "trading-bot",
+        "timestamp": datetime.now(timezone.utc).isoformat()
+    }
+
+
+@app.get("/health")
+def health():
+    """Kurzer Health Check."""
+    return {"ok": True}
+
+
+@app.post("/scan")
+async def scan():
+    """
+    Kompletter Bot-Zyklus.
+
+    1. Market Gate (BTC-Filter)
+    2. Universe laden
+    3. Screener
+    4. KI Entry + Validation
+    5. Exit-Check für offene Positionen
+    6. Logging
+    """
+    try:
+        return await _run_scan_cycle()
+    except Exception as e:
+        logger.error(f"CRITICAL: Scan cycle failed: {e}")
+        logger.error(traceback.format_exc())
+        return JSONResponse(
+            content={"status": "error", "message": str(e)},
+            status_code=500
+        )
+
+
+async def _run_scan_cycle() -> dict:
+    """Interne Scan-Logik."""
+    result = {
+        "status": "ok",
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "market_gate_passed": False,
+        "market_gate_reason": "",
+        "candidates_found": 0,
+        "trades_opened": 0,
+        "trades_closed": 0,
+        "errors": []
+    }
+
+    # ── BTC Preis loggen ──
+    try:
+        btc_price = get_current_price("BTCUSDT")
+        if db_configured():
+            log_btc_price(btc_price)
+    except Exception as e:
+        logger.warning(f"BTC-Preis konnte nicht geladen werden: {e}")
+        btc_price = 0
+
+    # ── Stage 0: Market Gate ──
+    gate_result = market_gate_check()
+    result["market_gate_passed"] = gate_result.passed
+    result["market_gate_reason"] = gate_result.reason
+
+    if not gate_result.passed:
+        logger.info(f"Market Gate BLOCKED: {gate_result.reason}")
+        if db_configured():
+            log_scan(result)
+        return result
+
+    # ── Stage 1: Universe + Screener ──
+    try:
+        universe = get_top100_universe()
+    except Exception as e:
+        result["errors"].append(f"Universe Fehler: {e}")
+        if db_configured():
+            log_scan(result)
+        return result
+
+    # Blacklist aus DB
+    blacklist = set()
+    if db_configured():
+        # Blacklist wird im Screener gefiltert
+        pass
+
+    candidates = run_screener(universe, blacklist=blacklist)
+    result["candidates_found"] = len(candidates)
+
+    # ── Stage 2+3: KI Entry + Validation ──
+    trades_opened = 0
+    for candidate in candidates:
+        # Berechne Positionsgröße
+        # (vereinfacht: fixe Größe basierend auf Portfolio)
+        position_size = 50.0  # $50 pro Trade als Default
+
+        # KI Entry Decision
+        btc_context = {
+            "btc_4h_pct": gate_result.btc_4h_change_pct,
+            "btc_above_ema50": gate_result.btc_above_ema50
+        }
+
+        try:
+            from data.binance import get_klines
+            klines = get_klines(candidate.symbol, "15m", 100)
+
+            decision = get_entry_decision(
+                symbol=candidate.symbol,
+                price=candidate.price,
+                position_size_usd=position_size,
+                ohlcv_data=klines,
+                indicators=candidate.indicators,
+                screener_reason=", ".join(candidate.reasons),
+                btc_context=btc_context
+            )
+        except Exception as e:
+            logger.error(f"KI Entry Fehler für {candidate.symbol}: {e}")
+            continue
+
+        # Validation
+        is_valid, reason = validate_entry_decision(decision, candidate.price)
+        if not is_valid:
+            logger.info(f"Entry abgelehnt für {candidate.symbol}: {reason}")
+            continue
+
+        # Max Positionen prüfen
+        open_count = get_open_position_count()
+        if open_count >= 3:  # MAX_OPEN_POSITIONS
+            logger.info(f"Max Positionen erreicht, {candidate.symbol} übersprungen")
+            continue
+
+        # Position öffnen
+        trade_id = open_position(
+            symbol=candidate.symbol,
+            entry_price=decision.get("entry_price", candidate.price),
+            position_size_usd=position_size,
+            stop_loss=decision["stop_loss"],
+            take_profit_1=decision["take_profit_1"],
+            take_profit_2=decision["take_profit_2"],
+            entry_atr=candidate.atr,
+            risk_reward_ratio=decision.get("risk_reward_ratio", 0),
+            learning_tags=decision.get("learning_tags", [])
+        )
+
+        if trade_id:
+            trades_opened += 1
+
+    result["trades_opened"] = trades_opened
+
+    # ── Exit-Check für offene Positionen ──
+    trades_closed = 0
+    open_positions = get_all_open_positions()
+
+    for position in open_positions:
+        try:
+            current_price = get_current_price(position["symbol"])
+
+            btc_context = {
+                "btc_15min_pct": 0,  # TODO: implement
+                "btc_1h_pct": 0
+            }
+
+            exit_decision = process_exit(position, current_price, btc_context)
+
+            if exit_decision == "SELL":
+                success = close_position(
+                    trade_id=position["id"],
+                    exit_price=current_price,
+                    exit_reason="KI_Exit" if "KI" in str(position.get("exit_reason", "")) else "Signal",
+                    symbol=position["symbol"]
+                )
+                if success:
+                    trades_closed += 1
+
+            elif exit_decision == "PARTIAL_SELL":
+                success = close_partial_position(
+                    trade_id=position["id"],
+                    exit_price=current_price,
+                    exit_reason="TP1_Partial_Exit",
+                    symbol=position["symbol"]
+                )
+                if success:
+                    trades_closed += 1
+
+        except Exception as e:
+            logger.error(f"Exit-Check Fehler für {position['symbol']}: {e}")
+
+    result["trades_closed"] = trades_closed
+
+    # ── Scan loggen ──
+    if db_configured():
+        log_scan(result)
+
+    logger.info(
+        f"Scan abgeschlossen: "
+        f"Candidates={result['candidates_found']}, "
+        f"Opened={result['trades_opened']}, "
+        f"Closed={result['trades_closed']}"
+    )
+
+    return result
+
+
+@app.get("/positions")
+def positions():
+    """Gibt alle offenen Positionen zurück."""
+    open_pos = get_all_open_positions()
+    return {"positions": open_pos, "count": len(open_pos)}
+
+
+@app.get("/status")
+def status():
+    """Bot Status."""
+    return {
+        "status": "running",
+        "supabase_configured": db_configured(),
+        "open_positions": get_open_position_count()
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

config.py

@@ -0,0 +1,121 @@
+"""
+config.py — Zentrale Konfiguration für den Trading Bot.
+
+Alle Parameter an einem Ort. Niemals Werte direkt im Code hardcoden.
+Secrets kommen aus Umgebungsvariablen oder .env Datei.
+"""
+
+import os
+from dotenv import load_dotenv
+
+# .env Datei laden (für lokale Entwicklung)
+load_dotenv()
+
+
+# ──────────────────────────────────────────────
+# Binance API
+# ──────────────────────────────────────────────
+BINANCE_BASE_URL = "https://api.binance.com"
+BINANCE_TIMEOUT_SECONDS = 10
+BINANCE_RETRIES = 3
+BINANCE_BACKOFF_BASE = 1.5  # Exponential Backoff Basis in Sekunden
+
+
+# ──────────────────────────────────────────────
+# Screener
+# ──────────────────────────────────────────────
+SCREENER_INTERVAL_MINUTES = 15
+EXIT_CHECK_INTERVAL_MINUTES = 5
+UNIVERSE_SIZE = 100
+MIN_LIQUIDITY_USD = 5_000_000
+SCREENER_PASS_SCORE = 6
+MAX_CANDIDATES_PER_CYCLE = 3
+
+# FOMO-Schutz: Preis +10% in letzten 8 Kerzen → Ausschluss
+FOMO_PRICE_RISE_PCT = 10.0
+FOMO_LOOKBACK_CANDLES = 8
+
+# Volume Spike Schwellen
+VOLUME_SPIKE_THRESHOLD = 1.5
+
+# Momentum
+MOMENTUM_MIN_PCT = 1.5
+MOMENTUM_MAX_PCT = 5.0
+MOMENTUM_LOOKBACK_CANDLES = 8
+
+
+# ──────────────────────────────────────────────
+# Positionen
+# ──────────────────────────────────────────────
+MAX_OPEN_POSITIONS = 3
+PORTFOLIO_VALUE_USD = 1000.0
+RISK_PER_TRADE_PCT = 1.5
+COOLDOWN_AFTER_SL_HOURS = 4
+
+
+# ──────────────────────────────────────────────
+# ATR-Multiplikatoren
+# ──────────────────────────────────────────────
+ATR_STOP_LOSS_MULT = 1.5
+ATR_TP1_MULT = 3.0       # R:R 1:2
+ATR_TP2_MULT = 5.25      # R:R 1:3.5
+ATR_TRAILING_ACTIVATION_MULT = 1.5
+ATR_TRAILING_DISTANCE_MULT = 1.5
+
+
+# ──────────────────────────────────────────────
+# Entry KI
+# ──────────────────────────────────────────────
+ENTRY_MIN_CONFIDENCE = 7
+ENTRY_MIN_RR = 2.0
+
+
+# ──────────────────────────────────────────────
+# Exit KI
+# ──────────────────────────────────────────────
+EXIT_MIN_CONFIDENCE = 6
+MAX_HOLD_COUNT = 3
+
+
+# ──────────────────────────────────────────────
+# BTC Filter (Stage 0)
+# ──────────────────────────────────────────────
+BTC_FILTER_4H_DROP = -2.5
+BTC_FILTER_4H_PUMP = 4.0
+BTC_CRASH_FAST_PCT = -1.5      # 15min Change
+BTC_CRASH_CONFIRM_PCT = -2.5   # 1h Change
+
+
+# ──────────────────────────────────────────────
+# Time Stops
+# ──────────────────────────────────────────────
+TIME_STOP_A_HOURS = 4
+TIME_STOP_A_PNL_PCT = -0.5
+TIME_STOP_B_HOURS = 2
+
+
+# ──────────────────────────────────────────────
+# KI Provider (austauschbar)
+# ──────────────────────────────────────────────
+AI_PROVIDER = os.getenv("AI_PROVIDER", "anthropic")  # "anthropic", "openai", "ollama"
+AI_MODEL_NAME = os.getenv("AI_MODEL_NAME", "")      # Leer = Provider-Default
+
+
+# ──────────────────────────────────────────────
+# Supabase
+# ──────────────────────────────────────────────
+SUPABASE_URL = os.getenv("SUPABASE_URL", "")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY", "")
+
+
+# ──────────────────────────────────────────────
+# Stablecoins & Leveraged Tokens (Ausschluss)
+# ────────────────────────────────��─────────────
+STABLECOINS = {"USDT", "USDC", "BUSD", "DAI", "TUSD", "FDUSD", "USDD", "TUSDE"}
+LEVERAGED_TOKEN_PATTERNS = {"UP", "DOWN", "3L", "3S", "BEAR", "BULL"}
+
+
+# ──────────────────────────────────────────────
+# Logging
+# ──────────────────────────────────────────────
+LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")

dashboard/__init__.py

@@ -0,0 +1 @@
+"""dashboard — Streamlit Dashboard."""

dashboard/dashboard.py

@@ -0,0 +1,52 @@
+"""
+dashboard.py — Streamlit Dashboard für den Trading Bot.
+
+Zeigt offene Positionen, Trade-Historie und Scan-Logs.
+Starten mit: streamlit run dashboard/dashboard.py
+"""
+
+import streamlit as st
+import pandas as pd
+from datetime import datetime, timezone
+
+from db.supabase_client import (
+    get_open_positions, get_portfolio_value, is_configured
+)
+
+st.set_page_config(page_title="Trading Bot Dashboard", layout="wide")
+st.title("🤖 Trading Bot Dashboard")
+
+# ── Status ──
+col1, col2, col3 = st.columns(3)
+
+with col1:
+    st.metric("Status", "🟢 Online" if is_configured() else "🔴 Nicht konfiguriert")
+
+with col2:
+    portfolio_value = get_portfolio_value()
+    st.metric("Portfolio-Wert", f"${portfolio_value:,.2f}")
+
+with col3:
+    open_count = len(get_open_positions())
+    st.metric("Offene Positionen", open_count)
+
+st.divider()
+
+# ── Offene Positionen ──
+st.subheader("📈 Offene Positionen")
+
+positions = get_open_positions()
+if positions:
+    df = pd.DataFrame(positions)
+    df = df[["symbol", "entry_price", "position_size_usd", "stop_loss",
+             "take_profit_1", "opened_at", "learning_tags"]]
+    st.dataframe(df, use_container_width=True)
+else:
+    info = st.info("Keine offenen Positionen")
+
+st.divider()
+
+# ── Hinweise ──
+st.caption(
+    f"Letzte Aktualisierung: {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S')} UTC"
+)

data/__init__.py

@@ -0,0 +1 @@
+"""data — Marktdaten von Binance API."""

data/binance.py

@@ -0,0 +1,132 @@
+"""
+binance.py — Binance Public API Wrapper.
+
+Kein Account nötig. Alle Endpoints sind öffentlich.
+Inkl. Error Handling und Exponential Backoff bei Rate Limits.
+"""
+
+import time
+import logging
+import requests
+
+import config
+
+logger = logging.getLogger(__name__)
+
+
+class BinanceAPIError(Exception):
+    """Fehler bei Binance API Aufruf."""
+    pass
+
+
+class BinanceRateLimitError(BinanceAPIError):
+    """Binance Rate Limit wurde erreicht."""
+    pass
+
+
+def _request_with_retry(url: str, params: dict = None) -> dict | list:
+    """
+    GET-Request an Binance API mit Exponential Backoff.
+
+    Raises:
+        BinanceAPIError: Bei Timeout oder unerwartetem Fehler
+        BinanceRateLimitError: Bei Rate Limit (429)
+    """
+    backoff = config.BINANCE_BACKOFF_BASE
+
+    for attempt in range(config.BINANCE_RETRIES):
+        try:
+            response = requests.get(
+                url,
+                params=params,
+                timeout=config.BINANCE_TIMEOUT_SECONDS
+            )
+
+            if response.status_code == 429:
+                logger.warning(
+                    f"Binance Rate Limit (Versuch {attempt + 1}/{config.BINANCE_RETRIES}). "
+                    f"Warte {backoff:.1f}s..."
+                )
+                time.sleep(backoff)
+                backoff *= 2
+                continue
+
+            response.raise_for_status()
+            return response.json()
+
+        except requests.exceptions.Timeout:
+            logger.warning(
+                f"Binance Timeout (Versuch {attempt + 1}/{config.BINANCE_RETRIES}). "
+                f"Warte {backoff:.1f}s..."
+            )
+            if attempt < config.BINANCE_RETRIES - 1:
+                time.sleep(backoff)
+                backoff *= 2
+            else:
+                raise BinanceAPIError("Binance API Timeout nach allen Retries")
+
+        except requests.exceptions.RequestException as e:
+            raise BinanceAPIError(f"Binance Request Fehler: {e}")
+
+    raise BinanceRateLimitError("Binance Rate Limit — alle Retries aufgebraucht")
+
+
+def get_ticker_24hr() -> list[dict]:
+    """
+    Gibt alle 24h Ticker zurück.
+
+    Returns:
+        Liste von Dicts mit symbol, volume, quoteVolume, etc.
+    """
+    url = f"{config.BINANCE_BASE_URL}/api/v3/ticker/24hr"
+    return _request_with_retry(url)
+
+
+def get_klines(symbol: str, interval: str = "15m", limit: int = 100) -> list:
+    """
+    Holt OHLCV-Kerzen für ein Symbol.
+
+    Args:
+        symbol: z.B. "BTCUSDT"
+        interval: "15m", "1h", "4h", etc.
+        limit: Anzahl Kerzen (max 1000)
+
+    Returns:
+        Liste von [open_time, open, high, low, close, volume, close_time, ...]
+    """
+    url = f"{config.BINANCE_BASE_URL}/api/v3/klines"
+    params = {
+        "symbol": symbol,
+        "interval": interval,
+        "limit": limit
+    }
+    return _request_with_retry(url, params)
+
+
+def get_current_price(symbol: str) -> float:
+    """
+    Gibt den aktuellen Preis eines Symbols zurück.
+
+    Args:
+        symbol: z.B. "BTCUSDT"
+
+    Returns:
+        Aktueller Preis als Float
+    """
+    url = f"{config.BINANCE_BASE_URL}/api/v3/ticker/price"
+    params = {"symbol": symbol}
+    data = _request_with_retry(url, params)
+    return float(data["price"])
+
+
+def get_btc_4h_klines(limit: int = 50) -> list:
+    """
+    Holt BTC 4h-Kerzen für EMA50-Berechnung und 4h-Change.
+
+    Args:
+        limit: Anzahl Kerzen (50 reicht für EMA50 + 4h-Change)
+
+    Returns:
+        Liste von OHLCV-Kerzen
+    """
+    return get_klines("BTCUSDT", interval="4h", limit=limit)

data/universe.py

@@ -0,0 +1,103 @@
+"""
+universe.py — Top 100 Coins nach 24h Volume filtern.
+
+Filterregeln:
+- Nur USDT-Pairs
+- 24h Volume > MIN_LIQUIDITY_USD
+- Keine Stablecoins
+- Keine Leveraged Tokens
+- Sortiert nach Volume absteigend, Top 100
+"""
+
+import logging
+from dataclasses import dataclass
+
+import config
+from data.binance import get_ticker_24hr, BinanceAPIError
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class CoinInfo:
+    """Info über einen Coin aus dem Universe."""
+    symbol: str
+    volume_24h_usd: float
+    price: float
+
+
+def _is_stablecoin(symbol: str) -> bool:
+    """Prüft ob Symbol ein Stablecoin ist."""
+    base = symbol.replace("USDT", "").replace("USDC", "").replace("BUSD", "")
+    return base in config.STABLECOINS or symbol in config.STABLECOINS
+
+
+def _is_leveraged_token(symbol: str) -> bool:
+    """Prüft ob Symbol ein Leveraged Token ist."""
+    for pattern in config.LEVERAGED_TOKEN_PATTERNS:
+        if pattern in symbol.upper():
+            return True
+    return False
+
+
+def _is_usdt_pair(symbol: str) -> bool:
+    """Prüft ob Symbol ein USDT-Pair ist."""
+    return symbol.endswith("USDT")
+
+
+def get_top100_universe() -> list[CoinInfo]:
+    """
+    Holt und filtert die Top 100 Coins nach 24h Volume.
+
+    Returns:
+        Liste von CoinInfo, sortiert nach Volume absteigend
+
+    Raises:
+        BinanceAPIError: Bei API-Fehler
+    """
+    try:
+        tickers = get_ticker_24hr()
+    except BinanceAPIError as e:
+        logger.error(f"Fehler beim Laden der Ticker: {e}")
+        raise
+
+    coins = []
+
+    for ticker in tickers:
+        symbol = ticker["symbol"]
+
+        # Nur USDT-Pairs
+        if not _is_usdt_pair(symbol):
+            continue
+
+        # Keine Stablecoins
+        if _is_stablecoin(symbol):
+            continue
+
+        # Keine Leveraged Tokens
+        if _is_leveraged_token(symbol):
+            continue
+
+        volume_usd = float(ticker["quoteVolume"])
+        price = float(ticker["lastPrice"])
+
+        # Mindestliquidität
+        if volume_usd < config.MIN_LIQUIDITY_USD:
+            continue
+
+        coins.append(CoinInfo(
+            symbol=symbol,
+            volume_24h_usd=volume_usd,
+            price=price
+        ))
+
+    # Sortieren nach Volume absteigend, Top 100
+    coins.sort(key=lambda c: c.volume_24h_usd, reverse=True)
+    top100 = coins[:config.UNIVERSE_SIZE]
+
+    logger.info(
+        f"Universe: {len(tickers)} Ticker geladen, "
+        f"{len(coins)} nach Filterung, Top {len(top100)} ausgewählt"
+    )
+
+    return top100

db/__init__.py

@@ -0,0 +1 @@
+"""db — Supabase Datenbank-Client."""

db/supabase_client.py

@@ -0,0 +1,375 @@
+"""
+supabase_client.py — Alle Datenbank-Operationen.
+
+Kapselt alle Supabase-Aufrufe hinter einer einfachen API.
+Alle Methoden haben Fallbacks bei Fehlern.
+"""
+
+import logging
+from datetime import datetime, timezone
+from typing import Optional
+
+import config
+
+logger = logging.getLogger(__name__)
+
+# Supabase Client (lazy init)
+_client = None
+
+
+def _get_client():
+    """Gibt Supabase Client (erstellt ihn bei Bedarf)."""
+    global _client
+    if _client is None:
+        try:
+            from supabase import create_client
+            _client = create_client(config.SUPABASE_URL, config.SUPABASE_KEY)
+        except Exception as e:
+            logger.error(f"Supabase Client konnte nicht erstellt werden: {e}")
+            raise
+    return _client
+
+
+def is_configured() -> bool:
+    """Prüft ob Supabase konfiguriert ist."""
+    return bool(config.SUPABASE_URL and config.SUPABASE_KEY)
+
+
+def log_trade(position_data: dict) -> Optional[str]:
+    """
+    Erstellt einen neuen Trade in der `trades` Tabelle.
+
+    Args:
+        position_data: Dict mit allen Positionsdaten
+
+    Returns:
+        Trade ID oder None bei Fehler
+    """
+    if not is_configured():
+        logger.warning("Supabase nicht konfiguriert — Trade nicht geloggt")
+        return None
+
+    try:
+        client = _get_client()
+        result = client.table("trades").insert({
+            "symbol": position_data["symbol"],
+            "entry_price": position_data["entry_price"],
+            "position_size_usd": position_data["position_size_usd"],
+            "stop_loss": position_data["stop_loss"],
+            "take_profit_1": position_data["take_profit_1"],
+            "take_profit_2": position_data["take_profit_2"],
+            "entry_atr": position_data.get("entry_atr", 0),
+            "risk_reward_ratio": position_data.get("risk_reward_ratio", 0),
+            "entry_learning_tags": position_data.get("learning_tags", []),
+            "status": "open",
+            "opened_at": datetime.now(timezone.utc).isoformat(),
+            "hold_count": 0
+        }).execute()
+
+        trade_id = result.data[0]["id"] if result.data else None
+        logger.info(f"Trade erstellt: {position_data['symbol']} (ID: {trade_id})")
+        return trade_id
+
+    except Exception as e:
+        logger.error(f"Fehler beim Erstellen von Trade: {e}")
+        return None
+
+
+def close_trade(
+    trade_id: str,
+    exit_price: float,
+    exit_reason: str,
+    exit_tags: list[str] = None,
+    pnl_pct: float = 0.0,
+    pnl_usd: float = 0.0
+) -> bool:
+    """
+    Schließt einen Trade.
+
+    Args:
+        trade_id: ID des Trades
+        exit_price: Verkaufspreis
+        exit_reason: Grund des Exits
+        exit_tags: Learning Tags
+        pnl_pct: P&L in Prozent
+        pnl_usd: P&L in USD
+
+    Returns:
+        True bei Erfolg
+    """
+    if not is_configured():
+        return False
+
+    try:
+        client = _get_client()
+        client.table("trades").update({
+            "exit_price": exit_price,
+            "exit_reason": exit_reason,
+            "exit_learning_tags": exit_tags or [],
+            "pnl_pct": pnl_pct,
+            "pnl_usd": pnl_usd,
+            "status": "closed",
+            "closed_at": datetime.now(timezone.utc).isoformat()
+        }).eq("id", trade_id).execute()
+
+        logger.info(f"Trade geschlossen: {trade_id} (Reason: {exit_reason})")
+        return True
+
+    except Exception as e:
+        logger.error(f"Fehler beim Schließen von Trade {trade_id}: {e}")
+        return False
+
+
+def get_open_positions() -> list[dict]:
+    """
+    Gibt alle offenen Positionen zurück.
+
+    Returns:
+        Liste von Trade-Dicts
+    """
+    if not is_configured():
+        return []
+
+    try:
+        client = _get_client()
+        result = client.table("trades").select("*").eq("status", "open").execute()
+        return result.data
+
+    except Exception as e:
+        logger.error(f"Fehler beim Laden offener Positionen: {e}")
+        return []
+
+
+def get_open_position_count() -> int:
+    """
+    Anzahl offener Positionen.
+
+    Returns:
+        Anzahl (0 bei Fehler)
+    """
+    if not is_configured():
+        return 0
+
+    try:
+        positions = get_open_positions()
+        return len(positions)
+
+    except Exception as e:
+        logger.error(f"Fehler beim Zählen offener Positionen: {e}")
+        return 0
+
+
+def update_position(trade_id: str, updates: dict) -> bool:
+    """
+    Aktualisiert ein Trade.
+
+    Args:
+        trade_id: ID des Trades
+        updates: Dict mit zu aktualisierenden Feldern
+
+    Returns:
+        True bei Erfolg
+    """
+    if not is_configured():
+        return False
+
+    try:
+        client = _get_client()
+        client.table("trades").update(updates).eq("id", trade_id).execute()
+        return True
+
+    except Exception as e:
+        logger.error(f"Fehler beim Updaten von Trade {trade_id}: {e}")
+        return False
+
+
+def increment_hold_count(trade_id: str, current_count: int) -> bool:
+    """
+    Erhöht den HOLD-Zähler um 1.
+
+    Args:
+        trade_id: ID des Trades
+        current_count: Aktueller HOLD-Count
+
+    Returns:
+        True bei Erfolg
+    """
+    return update_position(trade_id, {"hold_count": current_count + 1})
+
+
+def log_scan(scan_result: dict) -> bool:
+    """
+    Loggt einen Scan-Zyklus.
+
+    Args:
+        scan_result: Dict mit Scan-Ergebnis
+
+    Returns:
+        True bei Erfolg
+    """
+    if not is_configured():
+        return False
+
+    try:
+        client = _get_client()
+        client.table("scan_logs").insert({
+            "market_gate_passed": scan_result.get("market_gate_passed", False),
+            "market_gate_reason": scan_result.get("market_gate_reason", ""),
+            "candidates_found": scan_result.get("candidates_found", 0),
+            "candidates": scan_result.get("candidates", []),
+            "ai_decisions": scan_result.get("ai_decisions", {}),
+            "scanned_at": datetime.now(timezone.utc).isoformat()
+        }).execute()
+
+        logger.info("Scan geloggt")
+        return True
+
+    except Exception as e:
+        logger.error(f"Fehler beim Loggen des Scans: {e}")
+        return False
+
+
+def log_btc_price(price: float) -> bool:
+    """
+    Speichert aktuellen BTC-Preis.
+
+    Args:
+        price: Aktueller BTC-Preis
+
+    Returns:
+        True bei Erfolg
+    """
+    if not is_configured():
+        return False
+
+    try:
+        client = _get_client()
+        client.table("btc_price_log").insert({
+            "price": price,
+            "logged_at": datetime.now(timezone.utc).isoformat()
+        }).execute()
+        return True
+
+    except Exception as e:
+        logger.error(f"Fehler beim Loggen von BTC-Preis: {e}")
+        return False
+
+
+def get_btc_price_minutes_ago(minutes: int = 15) -> Optional[float]:
+    """
+    Holt BTC-Preis von vor X Minuten.
+
+    Args:
+        minutes: Vergangenheit in Minuten
+
+    Returns:
+        BTC-Preis oder None
+    """
+    if not is_configured():
+        return None
+
+    try:
+        client = _get_client()
+        result = client.table("btc_price_log") \
+            .select("price") \
+            .order("logged_at", desc=True) \
+            .limit(10) \
+            .execute()
+
+        if not result.data:
+            return None
+
+        # Nimm den ältesten Eintrag der letzten ~20 Minuten
+        # (da wir nur alle 5 Min loggen, ist der 3. Eintrag ca. 15 Min alt)
+        index = min(minutes // 5, len(result.data) - 1)
+        return result.data[index]["price"]
+
+    except Exception as e:
+        logger.error(f"Fehler beim Laden von BTC-Preis: {e}")
+        return None
+
+
+def is_blacklisted(symbol: str) -> bool:
+    """
+    Prüft ob ein Coin auf der Blacklist ist.
+
+    Args:
+        symbol: Coin Symbol
+
+    Returns:
+        True wenn auf Blacklist
+    """
+    if not is_configured():
+        return False
+
+    try:
+        client = _get_client()
+        result = client.table("blacklist") \
+            .select("symbol") \
+            .eq("symbol", symbol) \
+            .gt("expires_at", datetime.now(timezone.utc).isoformat()) \
+            .execute()
+
+        return len(result.data) > 0
+
+    except Exception as e:
+        logger.error(f"Fehler bei Blacklist-Check für {symbol}: {e}")
+        return False
+
+
+def add_to_blacklist(symbol: str, reason: str, hours: int = None) -> bool:
+    """
+    Fügt einen Coin zur Blacklist hinzu.
+
+    Args:
+        symbol: Coin Symbol
+        reason: Grund
+        hours: Dauer in Default (Default: config.COOLDOWN_AFTER_SL_HOURS)
+
+    Returns:
+        True bei Erfolg
+    """
+    if not is_configured():
+        return False
+
+    if hours is None:
+        hours = config.COOLDOWN_AFTER_SL_HOURS
+
+    try:
+        client = _get_client()
+        expires_at = datetime.now(timezone.utc).__class__.now(timezone.utc)
+        from datetime import timedelta
+        expires_at = datetime.now(timezone.utc) + timedelta(hours=hours)
+
+        client.table("blacklist").upsert({
+            "symbol": symbol,
+            "reason": reason,
+            "expires_at": expires_at.isoformat()
+        }).execute()
+
+        logger.info(f"{symbol} auf Blacklist gesetzt ({hours}h) — Grund: {reason}")
+        return True
+
+    except Exception as e:
+        logger.error(f"Fehler beim Setzen von Blacklist für {symbol}: {e}")
+        return False
+
+
+def get_portfolio_value() -> float:
+    """
+    Berechnet aktuellen Portfolio-Wert (offene Positionen + Startkapital).
+
+    Returns:
+        Portfolio-Wert in USD
+    """
+    if not is_configured():
+        return config.PORTFOLIO_VALUE_USD
+
+    try:
+        positions = get_open_positions()
+        total_pnl = sum(p.get("pnl_usd", 0) for p in positions)
+        return config.PORTFOLIO_VALUE_USD + total_pnl
+
+    except Exception as e:
+        logger.error(f"Fehler bei Portfolio-Berechnung: {e}")
+        return config.PORTFOLIO_VALUE_USD

positions/__init__.py

@@ -0,0 +1 @@
+"""positions — Position Management und Exit-Logik."""

positions/exit_logic.py

@@ -0,0 +1,392 @@
+"""
+exit_logic.py — Komplette Exit-Architektur.
+
+Stage 1: Harte Sicherheitsnetze (immer, alle 5 Min, keine KI)
+Stage 2: Sell-Screener (alle 15 Min, nur auf Kerzenabschluss)
+Stage 3: KI Exit-Entscheidung (nur bei Sell-Screener Score 2-3)
+Stage 4: Backend-Validation Exit
+"""
+
+import logging
+from datetime import datetime, timezone
+
+import config
+from data.binance import get_klines, get_current_price, BinanceAPIError
+from screener.indicators import (
+    calculate_rsi, calculate_macd, calculate_ema,
+    calculate_atr, calculate_volume_ratio
+)
+from ai.exit_prompt import get_exit_decision
+from ai.validator import validate_exit_decision
+from db.supabase_client import (
+    get_open_position_count, update_position, get_btc_price_minutes_ago
+)
+
+logger = logging.getLogger(__name__)
+
+
+# ──────────────────────────────────────────────
+# Stage 1: Harte Sicherheitsnetze
+# ──────────────────────────────────────────────
+
+def check_hard_stops(position: dict, current_price: float) -> tuple[bool, str]:
+    """
+    Prüft harte Exit-Trigger. Erster Trigger gewinnt.
+
+    Args:
+        position: Position Dict
+        current_price: Aktueller Preis
+
+    Returns:
+        Tuple von (exit_triggered, exit_tag)
+    """
+    symbol = position["symbol"]
+    entry_price = position["entry_price"]
+    stop_loss = position.get("stop_loss", 0)
+    take_profit_1 = position.get("take_profit_1", 0)
+    take_profit_2 = position.get("take_profit_2", 0)
+    trailing_stop = position.get("trailing_stop")
+    trailing_active = position.get("trailing_active", False)
+    tp1_hit = position.get("tp1_hit", False)
+
+    # 1. Harter Stop Loss
+    if stop_loss and current_price <= stop_loss:
+        logger.info(f"EXIT: Harter Stop Loss für {symbol} (Preis: {current_price} ≤ SL: {stop_loss})")
+        return True, "Hit_Hard_Stop"
+
+    # 2. Take Profit 2 (restliche 50%)
+    if tp1_hit and take_profit_2 and current_price >= take_profit_2:
+        logger.info(f"EXIT: TP2 erreicht für {symbol}")
+        return True, "TP2_Full_Exit"
+
+    # 3. Take Profit 1 (50% Partial)
+    if not tp1_hit and take_profit_1 and current_price >= take_profit_1:
+        logger.info(f"EXIT: TP1 erreicht für {symbol}")
+        return True, "TP1_Partial_Exit"
+
+    # 4. Trailing Stop
+    if trailing_active and trailing_stop and current_price <= trailing_stop:
+        logger.info(f"EXIT: Trailing Stop für {symbol}")
+        return True, "Hit_Trailing_Stop"
+
+    # 5. Time Stop A: > 4h im Minus
+    opened_at = position.get("opened_at")
+    if opened_at:
+        duration_hours = _hours_since(opened_at)
+        pnl_pct = ((current_price - entry_price) / entry_price) * 100 if entry_price > 0 else 0
+
+        if duration_hours > config.TIME_STOP_A_HOURS and pnl_pct < config.TIME_STOP_A_PNL_PCT:
+            logger.info(f"EXIT: Time Stop A für {symbol} ({duration_hours:.1f}h, P&L: {pnl_pct:.2f}%)")
+            return True, "Time_Stop_Loss"
+
+    # 6. Time Stop B: > 2h ohne ATR-Bewegung
+    if opened_at and not tp1_hit:
+        duration_hours = _hours_since(opened_at)
+        entry_atr = position.get("entry_atr", 0)
+
+        if entry_atr > 0 and duration_hours > config.TIME_STOP_B_HOURS:
+            target_price = entry_price + entry_atr
+            if current_price < target_price and pnl_pct < 0:
+                logger.info(f"EXIT: Time Stop B für {symbol} (keine ATR-Bewegung)")
+                return True, "Time_Stop_NoMovement"
+
+    # 7. BTC Crash schnell (15min)
+    btc_15min = _get_btc_change_15min()
+    if btc_15min is not None and btc_15min < config.BTC_CRASH_FAST_PCT:
+        logger.info(f"EXIT: BTC Crash Fast ({btc_15min}%) — alle Positionen")
+        return True, "BTC_Crash_Fast"
+
+    # 8. BTC Crash bestätigt (1h)
+    btc_1h = _get_btc_change_1h()
+    if btc_1h is not None and btc_1h < config.BTC_CRASH_CONFIRM_PCT:
+        logger.info(f"EXIT: BTC Crash Confirmed ({btc_1h}%) — alle Positionen")
+        return True, "BTC_Crash_Confirmed"
+
+    return False, ""
+
+
+def update_trailing_stop(position: dict, current_price: float) -> dict:
+    """
+    Aktualisiert den Trailing Stop.
+
+    Aktivierung: Preis ≥ Entry + (ATR * 1.5)
+    Update: Neuer High - (ATR * 1.5), nie nach unten.
+
+    Args:
+        position: Position Dict
+        current_price: Aktueller Preis
+
+    Returns:
+        Aktualisiertes Position Dict
+    """
+    entry = position["entry_price"]
+    atr = position.get("entry_atr", 0)
+
+    if atr <= 0:
+        return position
+
+    activation_level = entry + (atr * config.ATR_TRAILING_ACTIVATION_MULT)
+
+    # Trailing aktivieren sobald Preis hoch genug
+    if not position["trailing_active"] and current_price >= activation_level:
+        position["trailing_active"] = True
+        position["trailing_stop"] = entry + (atr * 0.5)  # Break-Even-Puffer
+        position["stop_loss"] = entry * 1.001  # Hard Stop auf Break-Even
+        logger.info(f"Trailing aktiviert für {position['symbol']} @ ${current_price:.4f}")
+
+    # Trailing nachziehen (nie nach unten)
+    if position["trailing_active"] and current_price > position.get("highest_price", entry):
+        position["highest_price"] = current_price
+        new_trailing = current_price - (atr * config.ATR_TRAILING_DISTANCE_MULT)
+        position["trailing_stop"] = max(new_trailing, position.get("trailing_stop", 0))
+
+    return position
+
+
+# ──────────────────────────────────────────────
+# Stage 2: Sell-Screener
+# ──────────────────────────────────────────────
+
+def run_sell_screener(symbol: str, klines: list) -> tuple[int, list[str]]:
+    """
+    Sell-Screener für ambivalente Signale.
+
+    Args:
+        symbol: Coin Symbol
+        klines: OHLCV-Kerzen
+
+    Returns:
+        Tuple von (score, reasons)
+    """
+    score = 0
+    reasons = []
+
+    if len(klines) < 20:
+        return 0, ["TOO_LITTLE_DATA"]
+
+    closes = [float(k[4]) for k in klines]
+    volumes = [float(k[5]) for k in klines]
+
+    # RSI überkauft (> 78) → 2 Punkte
+    rsi = calculate_rsi(closes)
+    if rsi > 78:
+        score += 2
+        reasons.append(f"RSI_Overbought_{rsi:.0f}")
+
+    # MACD bearish Cross → 2 Punkte
+    if len(closes) >= 30:
+        macd_history = []
+        for i in range(len(closes) - 10, len(closes)):
+            subset = closes[:i + 1]
+            m = calculate_macd(subset)
+            macd_history.append(m)
+
+        if len(macd_history) >= 2:
+            prev = macd_history[-2]
+            curr = macd_history[-1]
+            if prev["line"] >= prev["signal"] and curr["line"] < curr["signal"]:
+                score += 2
+                reasons.append("MACD_Bearish_Cross")
+
+    # Volume-Einbruch → 1 Punkte
+    vol_ratio = calculate_volume_ratio(volumes, 20)
+    if vol_ratio < 0.5:
+        score += 1
+        reasons.append(f"Volume_Collapse_{vol_ratio:.1f}x")
+
+    # Preis unter EMA9 → 1 Punkte
+    ema9 = calculate_ema(closes, 9)
+    if closes[-1] < ema9:
+        score += 1
+        reasons.append("Price_Below_EMA9")
+
+    return score, reasons
+
+
+# ──────────────────────────────────────────────
+# Stage 3+4: KI Exit + Validation
+# ──────────────────────────────────────────────
+
+def process_exit(
+    position: dict,
+    current_price: float,
+    btc_context: dict
+) -> str:
+    """
+    Komplette Exit-Pipeline für eine Position.
+
+    Args:
+        position: Position Dict
+        current_price: Aktueller Preis
+        btc_context: BTC-Kontext
+
+    Returns:
+        "SELL", "HOLD" oder "PARTIAL_SELL"
+    """
+    symbol = position["symbol"]
+
+    # Stage 1: Harte Stops
+    exit_triggered, exit_tag = check_hard_stops(position, current_price)
+    if exit_triggered:
+        return "SELL"
+
+    # Trailing Update
+    position = update_trailing_stop(position, current_price)
+
+    # Stage 2: Sell-Screener (nur bei Kerzenabschluss)
+    try:
+        klines = get_klines(symbol, interval="15m", limit=100)
+        sell_score, sell_reasons = run_sell_screener(symbol, klines)
+    except BinanceAPIError:
+        return "HOLD"  # Bei Fehler: nichts tun
+
+    logger.info(f"Sell-Screener {symbol}: Score {sell_score} — {', '.join(sell_reasons)}")
+
+    # Score >= 4 → sofort SELL
+    if sell_score >= 4:
+        logger.info(f"Sell-Score {sell_score} >= 4 → sofort SELL für {symbol}")
+        return "SELL"
+
+    # Score 2-3 → KI fragen
+    if sell_score >= 2:
+        return _ask_ki_exit(position, current_price, klines, sell_reasons, btc_context)
+
+    # Score <= 1 → HOLD
+    return "HOLD"
+
+
+def _ask_ki_exit(
+    position: dict,
+    current_price: float,
+    klines: list,
+    sell_reasons: list[str],
+    btc_context: dict
+) -> str:
+    """
+    Fragt KI für Exit-Entscheidung (Stage 3 + 4).
+
+    Returns:
+        "SELL" oder "HOLD"
+    """
+    symbol = position["symbol"]
+    entry_price = position["entry_price"]
+    pnl_pct = ((current_price - entry_price) / entry_price) * 100 if entry_price > 0 else 0
+
+    # Haltedauer berechnen
+    opened_at = position.get("opened_at")
+    duration_minutes = _minutes_since(opened_at) if opened_at else 0
+
+    # Indikatoren berechnen
+    closes = [float(k[4]) for k in klines]
+    volumes = [float(k[5]) for k in klines]
+
+    indicators = {
+        "rsi": calculate_rsi(closes),
+        "macd": calculate_macd(closes),
+        "ema9": calculate_ema(closes, 9),
+        "volume_ratio_20": calculate_volume_ratio(volumes, 20),
+        "atr": calculate_atr(
+            [float(k[2]) for k in klines],
+            [float(k[3]) for k in klines],
+            closes
+        )
+    }
+
+    sell_reason = ", ".join(sell_reasons)
+
+    # KI Exit Decision
+    decision = get_exit_decision(
+        symbol=symbol,
+        entry_price=entry_price,
+        current_price=current_price,
+        pnl_percent=round(pnl_pct, 2),
+        duration_minutes=duration_minutes,
+        initial_stop=position.get("stop_loss", 0),
+        current_trailing_stop=position.get("trailing_stop"),
+        tp1_hit=position.get("tp1_hit", False),
+        hold_count=position.get("hold_count", 0),
+        ohlcv_data=klines,
+        indicators=indicators,
+        sell_reason=sell_reason,
+        btc_context=btc_context
+    )
+
+    # Stage 4: Backend-Validation
+    final_decision = validate_exit_decision(
+        decision=decision,
+        current_price=current_price,
+        current_trailing_stop=position.get("trailing_stop"),
+        hold_count=position.get("hold_count", 0)
+    )
+
+    # Trailing Stop Update wenn KI einen vorschlägt
+    new_stop = decision.get("new_trailing_stop_usd")
+    if new_stop and final_decision == "HOLD":
+        position["trailing_stop"] = new_stop
+        update_position(position["id"], {"trailing_stop": new_stop})
+
+    # HOLD Count updaten
+    if final_decision == "HOLD":
+        increment_hold_count(position["id"], position.get("hold_count", 0))
+    else:
+        # SELL → HOLD Count reset
+        update_position(position["id"], {"hold_count": 0})
+
+    logger.info(f"KI Exit {symbol}: {final_decision} (KI: {decision.get('decision')})")
+    return final_decision
+
+
+# ──────────────────────────────────────────────
+# Hilfsfunktionen
+# ──────────────────────────────────────────────
+
+def _hours_since(timestamp_str: str) -> float:
+    """Berechnet Stunden seit einem ISO-Timestamp."""
+    try:
+        if isinstance(timestamp_str, str):
+            dt = datetime.fromisoformat(timestamp_str.replace("Z", "+00:00"))
+        else:
+            dt = timestamp_str
+        delta = datetime.now(timezone.utc) - dt
+        return delta.total_seconds() / 3600
+    except Exception:
+        return 0.0
+
+
+def _minutes_since(timestamp_str: str) -> int:
+    """Berechnet Minuten seit einem ISO-Timestamp."""
+    try:
+        if isinstance(timestamp_str, str):
+            dt = datetime.fromisoformat(timestamp_str.replace("Z", "+00:00"))
+        else:
+            dt = timestamp_str
+        delta = datetime.now(timezone.utc) - dt
+        return int(delta.total_seconds() / 60)
+    except Exception:
+        return 0
+
+
+def _get_btc_change_15min() -> float | None:
+    """BTC 15min-Change in %."""
+    try:
+        current_price = get_current_price("BTCUSDT")
+        old_price = get_btc_price_minutes_ago(15)
+
+        if old_price and old_price > 0:
+            return ((current_price - old_price) / old_price) * 100
+    except Exception:
+        pass
+    return None
+
+
+def _get_btc_change_1h() -> float | None:
+    """BTC 1h-Change in %."""
+    try:
+        current_price = get_current_price("BTCUSDT")
+        old_price = get_btc_price_minutes_ago(60)
+
+        if old_price and old_price > 0:
+            return ((current_price - old_price) / old_price) * 100
+    except Exception:
+        pass
+    return None

positions/manager.py

@@ -0,0 +1,216 @@
+"""
+manager.py — Position CRUD-Operationen.
+
+Kapselt alle Operationen rund um offene/geschlossene Positionen.
+"""
+
+import logging
+from datetime import datetime, timezone
+
+import config
+from db.supabase_client import (
+    log_trade, close_trade, get_open_positions,
+    get_open_position_count, update_position,
+    increment_hold_count, add_to_blacklist
+)
+
+logger = logging.getLogger(__name__)
+
+
+def open_position(
+    symbol: str,
+    entry_price: float,
+    position_size_usd: float,
+    stop_loss: float,
+    take_profit_1: float,
+    take_profit_2: float,
+    entry_atr: float,
+    risk_reward_ratio: float,
+    learning_tags: list[str] = None
+) -> str | None:
+    """
+    Öffnet eine neue Position (Paper-Trade).
+
+    Args:
+        symbol: Coin Symbol
+        entry_price: Einstiegspreis
+        position_size_usd: Positionsgröße in USD
+        stop_loss: Stop Loss
+        take_profit_1: Take Profit 1
+        take_profit_2: Take Profit 2
+        entry_atr: ATR bei Entry
+        risk_reward_ratio: R:R Verhältnis
+        learning_tags: Tags für Analyse
+
+    Returns:
+        Trade ID oder None bei Fehler
+    """
+    # Prüfe ob max Positionen erreicht
+    open_count = get_open_position_count()
+    if open_count >= config.MAX_OPEN_POSITIONS:
+        logger.warning(
+            f"Max Positionen erreicht ({open_count}/{config.MAX_OPEN_POSITIONS}). "
+            f"{symbol} wird nicht geöffnet."
+        )
+        return None
+
+    position_data = {
+        "symbol": symbol,
+        "entry_price": entry_price,
+        "position_size_usd": position_size_usd,
+        "stop_loss": stop_loss,
+        "take_profit_1": take_profit_1,
+        "take_profit_2": take_profit_2,
+        "entry_atr": entry_atr,
+        "risk_reward_ratio": risk_reward_ratio,
+        "learning_tags": learning_tags or []
+    }
+
+    trade_id = log_trade(position_data)
+
+    if trade_id:
+        logger.info(
+            f"Position geöffnet: {symbol} @ ${entry_price:.4f} "
+            f"(Size: ${position_size_usd:.2f}, SL: ${stop_loss:.4f})"
+        )
+
+    return trade_id
+
+
+def close_position(
+    trade_id: str,
+    exit_price: float,
+    exit_reason: str,
+    exit_tags: list[str] = None,
+    symbol: str = ""
+) -> bool:
+    """
+    Schließt eine Position komplett.
+
+    Args:
+        trade_id: Trade ID
+        exit_price: Verkaufspreis
+        exit_reason: Grund
+        exit_tags: Learning Tags
+        symbol: Symbol (für Blacklist)
+
+    Returns:
+        True bei Erfolg
+    """
+    from db.supabase_client import get_open_positions
+
+    # P&L berechnen
+    positions = get_open_positions()
+    position = next((p for p in positions if p["id"] == trade_id), None)
+
+    pnl_pct = 0.0
+    pnl_usd = 0.0
+
+    if position:
+        entry_price = position["entry_price"]
+        size = position["position_size_usd"]
+        if entry_price > 0:
+            pnl_pct = ((exit_price - entry_price) / entry_price) * 100
+            pnl_usd = size * (pnl_pct / 100)
+
+    success = close_trade(
+        trade_id=trade_id,
+        exit_price=exit_price,
+        exit_reason=exit_reason,
+        exit_tags=exit_tags or [],
+        pnl_pct=round(pnl_pct, 2),
+        pnl_usd=round(pnl_usd, 2)
+    )
+
+    if success:
+        logger.info(
+            f"Position geschlossen: {symbol} @ ${exit_price:.4f} "
+            f"(P&L: {pnl_pct:.2f}%, ${pnl_usd:.2f}) — Grund: {exit_reason}"
+        )
+
+        # Bei Stop Loss → Blacklist
+        if "Stop" in exit_reason or "Stop_Loss" in exit_reason:
+            if symbol:
+                add_to_blacklist(symbol, exit_reason)
+
+    return success
+
+
+def close_partial_position(
+    trade_id: str,
+    exit_price: float,
+    exit_reason: str,
+    symbol: str = ""
+) -> bool:
+    """
+    Schließt 50% der Position (nach TP1).
+    Stop wird auf Break-Even gesetzt.
+
+    Args:
+        trade_id: Trade ID
+        exit_price: Verkaufspreis
+        exit_reason: Grund
+        symbol: Symbol
+
+    Returns:
+        True bei Erfolg
+    """
+    from db.supabase_client import get_open_positions
+
+    positions = get_open_positions()
+    position = next((p for p in positions if p["id"] == trade_id), None)
+
+    if not position:
+        return False
+
+    entry_price = position["entry_price"]
+    size = position["position_size_usd"]
+    pnl_pct = ((exit_price - entry_price) / entry_price) * 100 if entry_price > 0 else 0
+    pnl_usd = size * (pnl_pct / 100)
+
+    # 50% verkaufen → position_size halbieren
+    new_size = size / 2
+
+    # Stop auf Break-Even setzen
+    updates = {
+        "position_size_usd": new_size,
+        "stop_loss": entry_price * 1.001,  # Break-Even + 0.1%
+        "tp1_hit": True,
+        "pnl_pct": round(pnl_pct, 2),
+        "pnl_usd": round(pnl_usd / 2, 2)
+    }
+
+    success = update_position(trade_id, updates)
+
+    if success:
+        logger.info(
+            f"Partial Exit (50%): {symbol} @ ${exit_price:.4f} "
+            f"(P&L: {pnl_pct:.2f}%) — Stop auf Break-Even"
+        )
+
+    return success
+
+
+def get_position_by_id(trade_id: str) -> dict | None:
+    """
+    Gibt eine Position zurück.
+
+    Args:
+        trade_id: Trade ID
+
+    Returns:
+        Position Dict oder None
+    """
+    from db.supabase_client import get_open_positions
+    positions = get_open_positions()
+    return next((p for p in positions if p["id"] == trade_id), None)
+
+
+def get_all_open_positions() -> list[dict]:
+    """
+    Gibt alle offenen Positionen zurück.
+
+    Returns:
+        Liste von Positionen
+    """
+    return get_open_positions()

requirements.txt

@@ -0,0 +1,10 @@
+numpy>=1.26
+requests>=2.31
+python-dotenv>=1.0
+supabase>=2.9
+fastapi>=0.115
+uvicorn>=0.30
+anthropic>=0.40
+openai>=1.55
+streamlit>=1.40
+pandas>=2.2

run_ai_test.py

@@ -0,0 +1,235 @@
+"""
+run_ai_test.py — Phase 2 Testscript.
+
+Testet KI-Prompts und Validation lokal mit Mocks.
+Kein API-Key nötig für Basis-Tests.
+
+Usage:
+    python run_ai_test.py
+"""
+
+import json
+import logging
+from unittest.mock import patch, MagicMock
+
+from ai.provider import parse_json_response, AIProviderError
+from ai.entry_prompt import build_entry_prompt, get_entry_decision
+from ai.exit_prompt import build_exit_prompt, get_exit_decision
+from ai.validator import validate_entry_decision, validate_exit_decision, calculate_position_size
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def test_json_parsing():
+    """Testet JSON-Extraktion aus verschiedenen KI-Antworten."""
+    print("\n[TEST] JSON Parsing")
+
+    # Fall 1: Direktes JSON
+    response1 = '{"decision": "BUY", "confidence": 8}'
+    result1 = parse_json_response(response1)
+    assert result1["decision"] == "BUY"
+    assert result1["confidence"] == 8
+    print("  ✓ Direktes JSON")
+
+    # Fall 2: JSON mit Text davor
+    response2 = "Hier ist meine Analyse:\n\n{\"decision\": \"SKIP\", \"confidence\": 5}\n\nFertig."
+    result2 = parse_json_response(response2)
+    assert result2["decision"] == "SKIP"
+    print("  ✓ JSON mit Text davor/danach")
+
+    # Fall 3: JSON in Code-Block
+    response3 = '```json\n{"decision": "BUY", "confidence": 9}\n```'
+    result3 = parse_json_response(response3)
+    assert result3["decision"] == "BUY"
+    print("  ✓ JSON in Code-Block")
+
+    # Fall 4: Kaprottes JSON → Fehler
+    try:
+        parse_json_response("Das ist kein JSON")
+        assert False, "Sollte Fehler werfen"
+    except ValueError:
+        print("  ✓ Kaprottes JSON → ValueError")
+
+
+def test_entry_validation():
+    """Testet Entry-Validation."""
+    print("\n[TEST] Entry Validation")
+
+    # Fall 1: Valides BUY
+    valid_buy = {
+        "decision": "BUY",
+        "confidence": 8,
+        "entry_price": 100.0,
+        "stop_loss": 95.0,
+        "take_profit_1": 110.0,
+        "position_size_usd": 50.0
+    }
+    is_valid, reason = validate_entry_decision(valid_buy, 100.0)
+    assert is_valid, f"Sollte gültig sein: {reason}"
+    print("  ✓ Valides BUY akzeptiert")
+
+    # Fall 2: Confidence zu niedrig
+    low_conf = {**valid_buy, "confidence": 5}
+    is_valid, reason = validate_entry_decision(low_conf, 100.0)
+    assert not is_valid
+    assert "CONFIDENCE" in reason
+    print("  ✓ Niedrige Confidence abgelehnt")
+
+    # Fall 3: Stop über Entry
+    bad_sl = {**valid_buy, "stop_loss": 105.0}
+    is_valid, reason = validate_entry_decision(bad_sl, 100.0)
+    assert not is_valid
+    assert "STOP_ABOVE" in reason
+    print("  ✓ Stop über Entry abgelehnt")
+
+    # Fall 4: R:R zu niedrig
+    bad_rr = {**valid_buy, "take_profit_1": 102.0}
+    is_valid, reason = validate_entry_decision(bad_rr, 100.0)
+    assert not is_valid
+    assert "RR_TOO_LOW" in reason
+    print("  ✓ Niedriges R:R abgelehnt")
+
+    # Fall 5: Entscheidung ist SKIP
+    skip = {**valid_buy, "decision": "SKIP"}
+    is_valid, reason = validate_entry_decision(skip, 100.0)
+    assert not is_valid
+    print("  ✓ SKIP-Entscheidung abgelehnt")
+
+
+def test_exit_validation():
+    """Testet Exit-Validation."""
+    print("\n[TEST] Exit Validation")
+
+    # Fall 1: Valides SELL
+    valid_sell = {"decision": "SELL", "confidence": 8}
+    result = validate_exit_decision(valid_sell, 100.0, 90.0, 0)
+    assert result == "SELL"
+    print("  ✓ Valides SELL")
+
+    # Fall 2: Confidence zu niedrig → SELL
+    low_conf = {"decision": "HOLD", "confidence": 3}
+    result = validate_exit_decision(low_conf, 100.0, 90.0, 0)
+    assert result == "SELL"
+    print("  ✓ Niedrige Confidence → SELL")
+
+    # Fall 3: 3x HOLD → Zwangsverkauf
+    hold = {"decision": "HOLD", "confidence": 7}
+    result = validate_exit_decision(hold, 100.0, 90.0, 3)
+    assert result == "SELL"
+    print("  ✓ 3x HOLD → Zwangsverkauf")
+
+    # Fall 4: Neuer Trailing Stop über Preis → ignoriert
+    hold_with_stop = {"decision": "HOLD", "confidence": 7, "new_trailing_stop_usd": 105.0}
+    result = validate_exit_decision(hold_with_stop, 100.0, 90.0, 0)
+    assert result == "HOLD"
+    assert hold_with_stop["new_trailing_stop_usd"] is None
+    print("  ✓ Trailing Stop über Preis → ignoriert")
+
+    # Fall 5: Neuer Trailing Stop schlechter → ignoriert
+    hold_with_stop2 = {"decision": "HOLD", "confidence": 7, "new_trailing_stop_usd": 85.0}
+    result = validate_exit_decision(hold_with_stop2, 100.0, 90.0, 0)
+    assert result == "HOLD"
+    assert hold_with_stop2["new_trailing_stop_usd"] is None
+    print("  ✓ Trailing Stop schlechter → ignoriert")
+
+
+def test_position_size():
+    """Testet Positionsgrößen-Berechnung."""
+    print("\n[TEST] Position Size")
+
+    # Normalfall
+    size = calculate_position_size(100.0, 95.0)
+    assert size > 0
+    print(f"  ✓ Entry=100, SL=95 → Size=${size:.2f}")
+
+    # SL = Entry → 0
+    size = calculate_position_size(100.0, 100.0)
+    assert size == 0
+    print("  ✓ SL = Entry → Size=0")
+
+    # SL über Entry → 0
+    size = calculate_position_size(100.0, 105.0)
+    assert size == 0
+    print("  ✓ SL über Entry → Size=0")
+
+
+def test_entry_prompt_building():
+    """Testet Prompt-Building (ohne API-Call)."""
+    print("\n[TEST] Entry Prompt Building")
+
+    system, user = build_entry_prompt(
+        symbol="ETHUSDT",
+        price=2500.50,
+        position_size_usd=50.0,
+        ohlcv_data=[[1700000000000, 2500, 2510, 2490, 2505, 1000] for _ in range(10)],
+        indicators={
+            "rsi": 55.0,
+            "macd": {"line": 0.5, "signal": 0.3, "histogram": 0.2},
+            "ema9": 2490.0,
+            "ema21": 2480.0,
+            "ema50": 2450.0,
+            "volume_ratio_20": 1.8,
+            "volume_ratio_5": 2.1,
+            "atr": 15.5
+        },
+        screener_reason="Volume_Spike_2.1x, MACD_Cross",
+        btc_context={"btc_4h_pct": 1.2, "btc_above_ema50": True}
+    )
+
+    assert "ETHUSDT" in user
+    assert "2500.50" in user
+    assert "Volume_Spike" in user
+    assert "JSON" in user
+    print("  ✓ Prompt enthält alle Daten")
+
+    # Test mit Provider Mock
+    print("\n[TEST] Entry Decision mit Mock Provider")
+
+    mock_provider = MagicMock()
+    mock_provider.generate.return_value = json.dumps({
+        "decision": "BUY",
+        "confidence": 8,
+        "entry_price": 2500.50,
+        "stop_loss": 2470.0,
+        "take_profit_1": 2560.0,
+        "take_profit_2": 2640.0,
+        "risk_reward_ratio": 2.03,
+        "learning_tags": ["Volume_Breakout", "MACD_Cross"],
+        "reason": "Starker Volume-Breakout mit MACD-Bestätigung."
+    })
+
+    with patch("ai.entry_prompt.get_provider", return_value=mock_provider):
+        decision = get_entry_decision(
+            symbol="ETHUSDT",
+            price=2500.50,
+            position_size_usd=50.0,
+            ohlcv_data=[],
+            indicators={},
+            screener_reason="Volume_Spike",
+            btc_context={}
+        )
+
+    assert decision["decision"] == "BUY"
+    assert decision["confidence"] == 8
+    print(f"  ✓ Mock Decision: {decision['decision']} (Confidence: {decision['confidence']})")
+
+
+def main():
+    print("=" * 60)
+    print("  TRADING BOT — Phase 2 KI Test")
+    print("=" * 60)
+
+    test_json_parsing()
+    test_entry_validation()
+    test_exit_validation()
+    test_position_size()
+    test_entry_prompt_building()
+
+    print("\n" + "=" * 60)
+    print("  ALLE TESTS BESTANDEN ✓")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

run_db_test.py

@@ -0,0 +1,158 @@
+"""
+run_db_test.py — Phase 3 Testscript.
+
+Testet Supabase-Anbindung und DB-Operationen.
+Braucht SUPABASE_URL und SUPABASE_KEY in .env.
+
+Usage:
+    python run_db_test.py
+"""
+
+import logging
+from datetime import datetime, timezone
+from dotenv import load_dotenv
+
+load_dotenv()
+
+from db.supabase_client import (
+    log_trade, close_trade, get_open_positions, get_open_position_count,
+    update_position, log_scan, log_btc_price, get_btc_price_minutes_ago,
+    is_blacklisted, add_to_blacklist, get_portfolio_value, is_configured
+)
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def test_connection():
+    """Testet Supabase-Verbindung."""
+    print("\n[TEST] Supabase Verbindung")
+
+    if not is_configured():
+        print("  ✗ Supabase nicht konfiguriert!")
+        print("  → Setze SUPABASE_URL und SUPABASE_KEY in .env")
+        return False
+
+    print("  ✓ Supabase konfiguriert")
+    return True
+
+
+def test_trade_logging():
+    """Testet Trade-Erstellung und -Schließung."""
+    print("\n[TEST] Trade Logging")
+
+    # Trade erstellen
+    trade_data = {
+        "symbol": "TESTUSDT",
+        "entry_price": 100.0,
+        "position_size_usd": 50.0,
+        "stop_loss": 95.0,
+        "take_profit_1": 110.0,
+        "take_profit_2": 120.0,
+        "entry_atr": 2.5,
+        "risk_reward_ratio": 2.0,
+        "learning_tags": ["Volume_Breakout", "MACD_Cross"]
+    }
+
+    trade_id = log_trade(trade_data)
+    if not trade_id:
+        print("  ✗ Trade konnte nicht erstellt werden")
+        return False
+
+    print(f"  ✓ Trade erstellt: {trade_id}")
+
+    # Trade schließen
+    success = close_trade(
+        trade_id=trade_id,
+        exit_price=110.0,
+        exit_reason="TP1_Partial_Exit",
+        exit_tags=["Take_Profit"],
+        pnl_pct=10.0,
+        pnl_usd=5.0
+    )
+    print(f"  ✓ Trade geschlossen: {success}")
+
+    return True
+
+
+def test_btc_price_log():
+    """Testet BTC-Preis-Logging."""
+    print("\n[TEST] BTC Preis Log")
+
+    success = log_btc_price(67500.0)
+    print(f"  ✓ BTC-Preis geloggt: {success}")
+
+    price = get_btc_price_minutes_ago(15)
+    print(f"  ✓ BTC-Preis vor 15min: {price}")
+
+    return True
+
+
+def test_scan_log():
+    """Testet Scan-Logging."""
+    print("\n[TEST] Scan Log")
+
+    success = log_scan({
+        "market_gate_passed": True,
+        "market_gate_reason": "OK",
+        "candidates_found": 2,
+        "candidates": ["ETHUSDT", "SOLUSDT"],
+        "ai_decisions": {"ETHUSDT": "BUY", "SOLUSDT": "SKIP"}
+    })
+    print(f"  ✓ Scan geloggt: {success}")
+
+    return True
+
+
+def test_blacklist():
+    """Testet Blacklist-Funktion."""
+    print("\n[TEST] Blacklist")
+
+    # Hinzufügen
+    success = add_to_blacklist("TESTUSDT", "Stop Loss Hit", hours=1)
+    print(f"  ✓ Zur Blacklist hinzugefügt: {success}")
+
+    # Prüfen
+    blocked = is_blacklisted("TESTUSDT")
+    print(f"  ✓ Auf Blacklist: {blocked}")
+
+    # Nicht auf Blacklist
+    not_blocked = is_blacklisted("ETHUSDT")
+    print(f"  ✓ Nicht auf Blacklist (ETHUSDT): {not_blocked}")
+
+    return True
+
+
+def test_portfolio():
+    """Testet Portfolio-Berechnung."""
+    print("\n[TEST] Portfolio")
+
+    value = get_portfolio_value()
+    print(f"  ✓ Portfolio-Wert: ${value:.2f}")
+
+    return True
+
+
+def main():
+    print("=" * 60)
+    print("  TRADING BOT — Phase 3 Supabase Test")
+    print("=" * 60)
+
+    if not test_connection():
+        print("\n  ✗ Abgebrochen — Supabase nicht konfiguriert")
+        print("  Erstelle eine .env Datei mit SUPABASE_URL und SUPABASE_KEY")
+        return
+
+    test_trade_logging()
+    test_btc_price_log()
+    test_scan_log()
+    test_blacklist()
+    test_portfolio()
+
+    print("\n" + "=" * 60)
+    print("  TESTS ABGESCHLOSSEN")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

run_exit_test.py

@@ -0,0 +1,224 @@
+"""
+run_exit_test.py — Phase 4 Testscript.
+
+Testet Exit-Logik mit Mock-Daten.
+Kein API-Key nötig.
+
+Usage:
+    python run_exit_test.py
+"""
+
+import logging
+from datetime import datetime, timezone, timedelta
+from unittest.mock import patch, MagicMock
+
+from positions.exit_logic import (
+    check_hard_stops,
+    update_trailing_stop,
+    run_sell_screener,
+    process_exit
+)
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def test_hard_stop_loss():
+    """Testet Harter Stop Loss."""
+    print("\n[TEST] Harter Stop Loss")
+
+    position = {
+        "symbol": "TESTUSDT",
+        "entry_price": 100.0,
+        "stop_loss": 95.0,
+        "take_profit_1": 110.0,
+        "take_profit_2": 120.0,
+        "trailing_stop": None,
+        "trailing_active": False,
+        "tp1_hit": False,
+        "opened_at": datetime.now(timezone.utc).isoformat()
+    }
+
+    # Preis unter SL
+    triggered, tag = check_hard_stops(position, 94.0)
+    assert triggered
+    assert tag == "Hit_Hard_Stop"
+    print("  ✓ Harter SL triggered bei 94 (SL=95)")
+
+    # Preis über SL
+    triggered, tag = check_hard_stops(position, 96.0)
+    assert not triggered
+    print("  ✓ Kein SL bei 96 (SL=95)")
+
+
+def test_take_profit():
+    """Testet Take Profit 1 und 2."""
+    print("\n[TEST] Take Profit")
+
+    position = {
+        "symbol": "TESTUSDT",
+        "entry_price": 100.0,
+        "stop_loss": 95.0,
+        "take_profit_1": 110.0,
+        "take_profit_2": 120.0,
+        "trailing_stop": None,
+        "trailing_active": False,
+        "tp1_hit": False,
+        "opened_at": datetime.now(timezone.utc).isoformat()
+    }
+
+    # TP1 erreicht
+    triggered, tag = check_hard_stops(position, 111.0)
+    assert triggered
+    assert tag == "TP1_Partial_Exit"
+    print("  ✓ TP1 triggered bei 111 (TP1=110)")
+
+    # TP2 erreicht (tp1_hit=True)
+    position["tp1_hit"] = True
+    triggered, tag = check_hard_stops(position, 121.0)
+    assert triggered
+    assert tag == "TP2_Full_Exit"
+    print("  ✓ TP2 triggered bei 121 (TP2=120)")
+
+
+def test_trailing_stop():
+    """Testet Trailing Stop."""
+    print("\n[TEST] Trailing Stop")
+
+    position = {
+        "symbol": "TESTUSDT",
+        "entry_price": 100.0,
+        "entry_atr": 2.0,
+        "stop_loss": 95.0,
+        "take_profit_1": 110.0,
+        "take_profit_2": 120.0,
+        "trailing_stop": None,
+        "trailing_active": False,
+        "tp1_hit": False,
+        "opened_at": datetime.now(timezone.utc).isoformat()
+    }
+
+    # Preis unter Activation Level (Entry + ATR*1.5 = 103)
+    position = update_trailing_stop(position, 102.0)
+    assert not position["trailing_active"]
+    print("  ✓ Trailing nicht aktiv bei 102 (Activation: 103)")
+
+    # Preis über Activation
+    position = update_trailing_stop(position, 105.0)
+    assert position["trailing_active"]
+    assert position["trailing_stop"] == 101.0  # Entry + ATR*0.5
+    print(f"  ✓ Trailing aktiv bei 105, Stop: {position['trailing_stop']}")
+
+    # Preis steigt → Trailing nachziehen
+    position = update_trailing_stop(position, 110.0)
+    expected_stop = 110.0 - (2.0 * 1.5)  # 107.0
+    assert position["trailing_stop"] == expected_stop
+    print(f"  ✓ Trailing gezogen auf {position['trailing_stop']} bei Preis 110")
+
+    # Preis fällt unter Trailing
+    triggered, tag = check_hard_stops(position, 106.0)
+    assert triggered
+    assert tag == "Hit_Trailing_Stop"
+    print("  ✓ Trailing Stop triggered bei 106")
+
+
+def test_time_stops():
+    """Testet Time Stops."""
+    print("\n[TEST] Time Stops")
+
+    # Time Stop A: > 4h im Minus
+    old_time = (datetime.now(timezone.utc) - timedelta(hours=5)).isoformat()
+    position = {
+        "symbol": "TESTUSDT",
+        "entry_price": 100.0,
+        "stop_loss": 50.0,  # Weit unten
+        "take_profit_1": 200.0,  # Weit oben
+        "take_profit_2": 300.0,
+        "trailing_stop": None,
+        "trailing_active": False,
+        "tp1_hit": False,
+        "opened_at": old_time,
+        "entry_atr": 2.0
+    }
+
+    triggered, tag = check_hard_stops(position, 99.0)  # -1%
+    assert triggered
+    assert tag == "Time_Stop_Loss"
+    print("  ✓ Time Stop A nach 5h bei -1%")
+
+    # Time Stop B: > 2h ohne ATR-Bewegung
+    old_time = (datetime.now(timezone.utc) - timedelta(hours=3)).isoformat()
+    position["opened_at"] = old_time
+    position["stop_loss"] = 50.0
+    position["take_profit_1"] = 200.0
+
+    triggered, tag = check_hard_stops(position, 99.0)  # Nie Entry + ATR (102) erreicht
+    assert triggered
+    assert tag == "Time_Stop_NoMovement"
+    print("  ✓ Time Stop B nach 3h ohne ATR-Bewegung")
+
+
+def test_sell_screener():
+    """Testet Sell-Screener."""
+    print("\n[TEST] Sell-Screener")
+
+    # Simuliere Kerzen mit RSI > 78
+    base_klines = []
+    price = 100.0
+    for i in range(100):
+        # Steigender Preis → RSI hoch
+        price += 0.1
+        base_klines.append([0, price, price + 1, price - 1, price, 1000])
+
+    score, reasons = run_sell_screener("TESTUSDT", base_klines)
+    print(f"  ✓ Sell-Score: {score}, Reasons: {reasons}")
+    # Score sollte > 0 sein wegen steigendem Preis
+
+
+def test_trailing_never_moves_down():
+    """Testet dass Trailing Stop nie nach unten geht."""
+    print("\n[TEST] Trailing Stop nie nach unten")
+
+    position = {
+        "symbol": "TESTUSDT",
+        "entry_price": 100.0,
+        "entry_atr": 2.0,
+        "stop_loss": 95.0,
+        "take_profit_1": 110.0,
+        "take_profit_2": 120.0,
+        "trailing_stop": 105.0,
+        "trailing_active": True,
+        "tp1_hit": False,
+        "opened_at": datetime.now(timezone.utc).isoformat()
+    }
+
+    # Preis fällt → Trailing bleibt bei 105
+    position = update_trailing_stop(position, 103.0)
+    assert position["trailing_stop"] == 105.0
+    print("  ✓ Trailing bleibt bei 105 bei fallendem Preis")
+
+    # Preis steigt über vorheriges High
+    position = update_trailing_stop(position, 115.0)
+    assert position["trailing_stop"] > 105.0
+    print(f"  ✓ Trailing gezogen auf {position['trailing_stop']}")
+
+
+def main():
+    print("=" * 60)
+    print("  TRADING BOT — Phase 4 Exit-Logik Test")
+    print("=" * 60)
+
+    test_hard_stop_loss()
+    test_take_profit()
+    test_trailing_stop()
+    test_time_stops()
+    test_sell_screener()
+    test_trailing_never_moves_down()
+
+    print("\n" + "=" * 60)
+    print("  ALLE TESTS BESTANDEN ✓")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

run_full_test.py

@@ -0,0 +1,175 @@
+"""
+run_full_test.py — Komplett-Test fuer alle Phasen.
+
+Testet:
+1. Market Gate (BTC-Filter)
+2. Universe + Screener
+3. KI Entry Decision
+4. DB-Operationen
+5. Exit-Logik
+"""
+
+import logging
+import time
+import json
+from datetime import datetime
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+logger = logging.getLogger(__name__)
+
+
+def test_market_gate():
+    """Test Stage 0: Market Gate."""
+    print("\n=== STAGE 0: MARKET GATE ===")
+    from screener.market_gate import market_gate_check
+
+    result = market_gate_check()
+    print(f"Passed: {result.passed}")
+    print(f"Reason: {result.reason}")
+    print(f"BTC 4h: {result.btc_4h_change_pct}%")
+    print(f"BTC > EMA50: {result.btc_above_ema50}")
+    return result.passed
+
+
+def test_screener():
+    """Test Stage 1: Screener."""
+    print("\n=== STAGE 1: SCREENER ===")
+    from data.universe import get_top100_universe
+    from screener.screener import run_screener
+
+    universe = get_top100_universe()
+    print(f"Universe: {len(universe)} Coins")
+
+    start = time.time()
+    candidates = run_screener(universe)
+    duration = time.time() - start
+
+    print(f"Screener: {duration:.1f}s")
+    print(f"Kandidaten: {len(candidates)}")
+
+    for c in candidates:
+        print(f"  {c.symbol}: Score={c.score}, Reasons={', '.join(c.reasons)}")
+
+    return candidates
+
+
+def test_ki_entry():
+    """Test Stage 2: KI Entry."""
+    print("\n=== STAGE 2: KI ENTRY ===")
+    from ai.provider import get_provider, parse_json_response
+    from ai.validator import validate_entry_decision, calculate_position_size
+
+    provider = get_provider()
+    print(f"Provider: {type(provider).__name__}")
+    print(f"Model: {provider.model}")
+
+    # Test mit einfachem Prompt
+    system = "Du bist ein Trading-Bot. Antworte nur mit JSON."
+    user = 'ASSET: ETHUSDT PREIS: 3500. Antworte als JSON: {"decision": "SKIP", "confidence": 5, "reason": "Test"}'
+
+    response = provider.generate(system, user)
+    print(f"KI-Antwort: {response[:100]}")
+
+    # Test Validator
+    test_decision = {
+        "decision": "BUY",
+        "confidence": 8,
+        "entry_price": 100.0,
+        "stop_loss": 95.0,
+        "take_profit_1": 110.0,
+        "position_size_usd": 50.0
+    }
+
+    is_valid, reason = validate_entry_decision(test_decision, 100.0)
+    print(f"Validator (gueltiges BUY): {is_valid} - {reason}")
+
+    # Position Size
+    size = calculate_position_size(100.0, 95.0)
+    print(f"Position Size: ${size:.2f}")
+
+
+def test_db():
+    """Test Stage 3: DB."""
+    print("\n=== STAGE 3: DATABASE ===")
+    from db.supabase_client import (
+        is_configured, log_btc_price, log_scan,
+        get_open_position_count, get_portfolio_value
+    )
+
+    print(f"DB konfiguriert: {is_configured()}")
+
+    # BTC Preis loggen
+    success = log_btc_price(62534.92)
+    print(f"BTC Preis geloggt: {success}")
+
+    # Scan loggen
+    scan_success = log_scan({
+        "market_gate_passed": True,
+        "market_gate_reason": "OK",
+        "candidates_found": 0,
+        "candidates": [],
+        "ai_decisions": {}
+    })
+    print(f"Scan geloggt: {scan_success}")
+
+    # Portfolio
+    value = get_portfolio_value()
+    print(f"Portfolio-Wert: ${value:.2f}")
+
+    count = get_open_position_count()
+    print(f"Offene Positionen: {count}")
+
+
+def test_exit_logic():
+    """Test Stage 4: Exit."""
+    print("\n=== STAGE 4: EXIT LOGIC ===")
+    from positions.exit_logic import check_hard_stops, update_trailing_stop
+
+    # Test Harter Stop Loss
+    position = {
+        "symbol": "TESTUSDT",
+        "entry_price": 100.0,
+        "stop_loss": 95.0,
+        "take_profit_1": 110.0,
+        "take_profit_2": 120.0,
+        "trailing_stop": None,
+        "trailing_active": False,
+        "tp1_hit": False,
+        "opened_at": datetime.now().isoformat()
+    }
+
+    triggered, tag = check_hard_stops(position, 94.0)
+    print(f"Harter SL (Preis=94, SL=95): triggered={triggered}, tag={tag}")
+
+    # Test Trailing
+    position["entry_atr"] = 2.0
+    position = update_trailing_stop(position, 105.0)
+    print(f"Trailing aktiv: {position['trailing_active']}")
+    if position["trailing_active"]:
+        print(f"Trailing Stop: {position['trailing_stop']}")
+
+
+def main():
+    print("=" * 60)
+    print("  TRADING BOT -- Komplett Test")
+    print(f"  {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print("=" * 60)
+
+    gate_passed = test_market_gate()
+
+    if gate_passed:
+        test_screener()
+    else:
+        print("\n[Ubersprungen] Screener (Market Gate blockiert)")
+
+    test_ki_entry()
+    test_db()
+    test_exit_logic()
+
+    print("\n" + "=" * 60)
+    print("  ALLE TESTS ABGESCHLOSSEN")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

run_screener_test.py

@@ -0,0 +1,102 @@
+"""
+run_screener_test.py — Phase 1 Testscript.
+
+Startet den kompletten Screener lokal:
+1. Market Gate (BTC-Filter)
+2. Universe laden (Top 100)
+3. Screener über alle Coins
+4. Top 5 Kandidaten im Terminal
+
+Usage:
+    python run_screener_test.py
+"""
+
+import time
+import logging
+from datetime import datetime
+
+from screener.market_gate import market_gate_check
+from data.universe import get_top100_universe
+from screener.screener import run_screener
+
+# Logging konfigurieren
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    datefmt="%H:%M:%S"
+)
+logger = logging.getLogger(__name__)
+
+
+def main():
+    print("=" * 60)
+    print(f"  TRADING BOT -- Phase 1 Screener Test")
+    print(f"  {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print("=" * 60)
+    print()
+
+    start_time = time.time()
+
+    # ── Stage 0: Market Gate ──
+    print("[1/3] Market Gate (BTC-Filter)...")
+    gate_result = market_gate_check()
+
+    if not gate_result.passed:
+        print(f"  [BLOCKED] {gate_result.reason}")
+        print(f"  -> Kein Screener, kein Trade.")
+        return
+
+    print(f"  [PASSED] Market Gate OK")
+    print(f"    BTC 4h Change: {gate_result.btc_4h_change_pct}%")
+    print(f"    BTC ueber EMA50: {gate_result.btc_above_ema50}")
+    print()
+
+    # ── Universe laden ──
+    print("[2/3] Lade Top 100 Universe von Binance...")
+    universe = get_top100_universe()
+    print(f"  [OK] {len(universe)} Coins geladen")
+    if universe:
+        print(f"    Top 5 nach Volume:")
+        for i, coin in enumerate(universe[:5]):
+            vol_m = coin.volume_24h_usd / 1_000_000
+            print(f"      {i + 1}. {coin.symbol}: ${vol_m:.0f}M Vol")
+    print()
+
+    # ── Stage 1: Screener ──
+    print("[3/3] Screener laeuft (Top 100 -> Kandidaten)...")
+    screener_start = time.time()
+    candidates = run_screener(universe)
+    screener_duration = time.time() - screener_start
+
+    print(f"  [OK] Screener in {screener_duration:.1f}s abgeschlossen")
+    print()
+
+    # ── Ergebnisse ──
+    print("=" * 60)
+    print(f"  KANDIDATEN ({len(candidates)} gefunden)")
+    print("=" * 60)
+
+    if not candidates:
+        print("  Keine Kandidaten gefunden. Markt ist ruhig.")
+    else:
+        for i, c in enumerate(candidates):
+            print(f"\n  #{i + 1} {c.symbol}")
+            print(f"    Score: {c.score}/10")
+            print(f"    Preis: ${c.price:.6f}")
+            print(f"    ATR:   ${c.atr:.6f}")
+            print(f"    Gruende: {', '.join(c.reasons)}")
+
+    total_duration = time.time() - start_time
+    print()
+    print("=" * 60)
+    print(f"  GESAMT: {total_duration:.1f}s")
+    print("=" * 60)
+
+    if total_duration > 5.0:
+        print("  [WARNUNG] Laenger als 5 Sekunden! Performance optimieren.")
+    else:
+        print("  [OK] Performance < 5s")
+
+
+if __name__ == "__main__":
+    main()

schema.sql

@@ -0,0 +1,74 @@
+-- Trading Bot — Supabase SQL Schema
+-- Füge diese Datei im Supabase SQL Editor aus
+
+-- ──────────────────────────────────────────────
+-- Tabelle: trades
+-- ──────────────────────────────────────────────
+CREATE TABLE IF NOT EXISTS trades (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    symbol TEXT NOT NULL,
+    entry_price FLOAT NOT NULL,
+    exit_price FLOAT,
+    position_size_usd FLOAT NOT NULL,
+    stop_loss FLOAT NOT NULL,
+    take_profit_1 FLOAT NOT NULL,
+    take_profit_2 FLOAT NOT NULL,
+    entry_atr FLOAT NOT NULL DEFAULT 0,
+    pnl_pct FLOAT,
+    pnl_usd FLOAT,
+    risk_reward_ratio FLOAT,
+    entry_learning_tags TEXT[],
+    exit_learning_tags TEXT[],
+    exit_reason TEXT,
+    opened_at TIMESTAMPTZ DEFAULT NOW(),
+    closed_at TIMESTAMPTZ,
+    status TEXT DEFAULT 'open',   -- 'open', 'closed'
+    hold_count INT DEFAULT 0
+);
+
+-- ──────────────────────────────────────────────
+-- Tabelle: scan_logs
+-- ──────────────────────────────────────────────
+CREATE TABLE IF NOT EXISTS scan_logs (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    scanned_at TIMESTAMPTZ DEFAULT NOW(),
+    market_gate_passed BOOLEAN NOT NULL,
+    market_gate_reason TEXT,
+    candidates_found INT DEFAULT 0,
+    candidates TEXT[],
+    ai_decisions JSONB
+);
+
+-- ──────────────────────────────────────────────
+-- Tabelle: btc_price_log
+-- ──────────────────────────────────────────────
+CREATE TABLE IF NOT EXISTS btc_price_log (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    price FLOAT NOT NULL,
+    logged_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- Index für schnellere Abfragen
+CREATE INDEX IF NOT EXISTS idx_btc_price_log_logged_at
+    ON btc_price_log (logged_at DESC);
+
+-- ──────────────────────────────────────────────
+-- Tabelle: blacklist
+-- ──────────────────────────────────────────────
+CREATE TABLE IF NOT EXISTS blacklist (
+    symbol TEXT PRIMARY KEY,
+    reason TEXT,
+    expires_at TIMESTAMPTZ NOT NULL
+);
+
+-- Index für schnelle Blacklist-Checks
+CREATE INDEX IF NOT EXISTS idx_blacklist_expires
+    ON blacklist (expires_at);
+
+-- ──────────────────────────────────────────────
+-- Row Level Security deaktivieren (für Bot)
+-- ──────────────────────────────────────────────
+ALTER TABLE trades DISABLE ROW LEVEL SECURITY;
+ALTER TABLE scan_logs DISABLE ROW LEVEL SECURITY;
+ALTER TABLE btc_price_log DISABLE ROW LEVEL SECURITY;
+ALTER TABLE blacklist DISABLE ROW LEVEL SECURITY;

screener/__init__.py

@@ -0,0 +1 @@
+"""screener — Markt-Screener und Indikatoren-Berechnung."""

screener/indicators.py

@@ -0,0 +1,198 @@
+"""
+indicators.py — Technische Indikatoren berechnen.
+
+Alle Berechnungen nutzen nur numpy — keine externen Trading-Bibliotheken.
+Das ist wichtig für den Hugging Face Free Tier (wenig Speicher).
+"""
+
+import numpy as np
+
+
+def calculate_rsi(closes: list[float], period: int = 14) -> float:
+    """
+    Wilder RSI (Relative Strength Index).
+
+    Args:
+        closes: Liste der Schlusskurse (neueste am Ende)
+        period: RSI-Periode (Standard: 14)
+
+    Returns:
+        RSI Wert zwischen 0 und 100
+    """
+    if len(closes) < period + 1:
+        return 50.0  # Neutral wenn nicht genug Daten
+
+    arr = np.array(closes, dtype=np.float64)
+    deltas = np.diff(arr)
+
+    # Gewinne und Verluste trennen
+    gains = np.where(deltas > 0, deltas, 0.0)
+    losses = np.where(deltas < 0, -deltas, 0.0)
+
+    # Erste einfache Mittelung
+    avg_gain = np.mean(gains[:period])
+    avg_loss = np.mean(losses[:period])
+
+    # Wilder's Smoothing (exponentiell)
+    for i in range(period, len(gains)):
+        avg_gain = (avg_gain * (period - 1) + gains[i]) / period
+        avg_loss = (avg_loss * (period - 1) + losses[i]) / period
+
+    if avg_loss == 0:
+        return 100.0
+
+    rs = avg_gain / avg_loss
+    rsi = 100.0 - (100.0 / (1.0 + rs))
+
+    return round(rsi, 2)
+
+
+def calculate_ema(data: list[float], period: int) -> float:
+    """
+    Exponential Moving Average (EMA).
+
+    Args:
+        data: Liste der Werte (neueste am Ende)
+        period: EMA-Periode
+
+    Returns:
+        Aktueller EMA Wert
+    """
+    if len(data) < period:
+        return data[-1] if data else 0.0
+
+    arr = np.array(data, dtype=np.float64)
+    multiplier = 2.0 / (period + 1)
+
+    # EMA mit Startwert = SMA der ersten `period` Werte
+    ema = np.mean(arr[:period])
+
+    for value in arr[period:]:
+        ema = (value - ema) * multiplier + ema
+
+    return round(float(ema), 8)
+
+
+def calculate_macd(
+    closes: list[float],
+    fast: int = 12,
+    slow: int = 26,
+    signal_period: int = 9
+) -> dict:
+    """
+    MACD (Moving Average Convergence Divergence).
+
+    Args:
+        closes: Liste der Schlusskurse (neueste am Ende)
+        fast: Schnelle EMA-Periode (Standard: 12)
+        slow: Langsame EMA-Periode (Standard: 26)
+        signal_period: Signal EMA-Periode (Standard: 9)
+
+    Returns:
+        Dict mit "line", "signal", "histogram"
+    """
+    if len(closes) < slow + signal_period:
+        return {"line": 0.0, "signal": 0.0, "histogram": 0.0}
+
+    arr = np.array(closes, dtype=np.float64)
+
+    # MACD Line = EMA(fast) - EMA(slow)
+    macd_values = []
+    fast_ema = np.mean(closes[:fast])
+    slow_ema = np.mean(closes[:slow])
+    fast_mult = 2.0 / (fast + 1)
+    slow_mult = 2.0 / (slow + 1)
+
+    for i in range(slow, len(arr)):
+        fast_ema = (arr[i] - fast_ema) * fast_mult + fast_ema
+        slow_ema = (arr[i] - slow_ema) * slow_mult + slow_ema
+        macd_values.append(fast_ema - slow_ema)
+
+    if len(macd_values) < signal_period:
+        line = macd_values[-1] if macd_values else 0.0
+        return {"line": round(line, 8), "signal": 0.0, "histogram": 0.0}
+
+    # Signal Line = EMA der MACD Line
+    signal = np.mean(macd_values[:signal_period])
+    signal_mult = 2.0 / (signal_period + 1)
+
+    for val in macd_values[signal_period:]:
+        signal = (val - signal) * signal_mult + signal
+
+    line = macd_values[-1]
+    histogram = line - signal
+
+    return {
+        "line": round(float(line), 8),
+        "signal": round(float(signal), 8),
+        "histogram": round(float(histogram), 8)
+    }
+
+
+def calculate_atr(
+    highs: list[float],
+    lows: list[float],
+    closes: list[float],
+    period: int = 14
+) -> float:
+    """
+    Average True Range (ATR).
+
+    Args:
+        highs: Liste der Hochs (neueste am Ende)
+        lows: Liste der Tiefs (neueste am Ende)
+        closes: Liste der Schlusskurse (neueste am Ende)
+        period: ATR-Periode (Standard: 14)
+
+    Returns:
+        Aktueller ATR Wert
+    """
+    if len(highs) < period + 1:
+        return 0.0
+
+    high = np.array(highs, dtype=np.float64)
+    low = np.array(lows, dtype=np.float64)
+    close = np.array(closes, dtype=np.float64)
+
+    # True Range = max(high-low, |high-prev_close|, |low-prev_close|)
+    tr_values = []
+    for i in range(1, len(high)):
+        tr = max(
+            high[i] - low[i],
+            abs(high[i] - close[i - 1]),
+            abs(low[i] - close[i - 1])
+        )
+        tr_values.append(tr)
+
+    if len(tr_values) < period:
+        return float(np.mean(tr_values)) if tr_values else 0.0
+
+    # Wilder's Smoothing (wie RSI)
+    atr = np.mean(tr_values[:period])
+    for i in range(period, len(tr_values)):
+        atr = (atr * (period - 1) + tr_values[i]) / period
+
+    return round(float(atr), 8)
+
+
+def calculate_volume_ratio(volumes: list[float], period: int) -> float:
+    """
+    Volume Ratio: Aktuelles Volumen / Durchschnitt der letzten N Kerzen.
+
+    Args:
+        volumes: Liste der Volumina (neueste am Ende)
+        period: Lookback-Periode
+
+    Returns:
+        Volume Ratio (z.B. 1.5 = 50% über Durchschnitt)
+    """
+    if len(volumes) < period + 1:
+        return 1.0
+
+    current = volumes[-1]
+    avg = np.mean(volumes[-(period + 1):-1])
+
+    if avg == 0:
+        return 1.0
+
+    return round(current / avg, 2)

screener/market_gate.py

@@ -0,0 +1,132 @@
+"""
+market_gate.py — Stage 0: BTC-Markt-Gate.
+
+Läuft VOR jedem Zyklus. Wenn einer der Checks fehlschlägt → kompletter Abbruch.
+Ergebnis wird geloggt.
+"""
+
+import logging
+from dataclasses import dataclass
+
+import config
+from data.binance import (
+    get_ticker_24hr,
+    get_btc_4h_klines,
+    BinanceAPIError
+)
+from screener.indicators import calculate_ema
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class MarketGateResult:
+    """Ergebnis des Market Gates."""
+    passed: bool
+    reason: str
+    btc_4h_change_pct: float
+    btc_above_ema50: bool
+
+
+def _get_btc_4h_change() -> float:
+    """
+    Berechnet die BTC 4h-Änderung in Prozent.
+
+    Returns:
+        Prozentuale Änderung der letzten 4h (z.B. -2.5 für -2.5%)
+    """
+    klines = get_btc_4h_klines(limit=2)
+    if len(klines) < 2:
+        return 0.0
+
+    prev_close = float(klines[-2][4])  # Close der vorletzten 4h-Kerze
+    current_close = float(klines[-1][4])
+
+    if prev_close == 0:
+        return 0.0
+
+    change_pct = ((current_close - prev_close) / prev_close) * 100
+    return round(change_pct, 2)
+
+
+def _is_btc_above_ema50_4h() -> bool:
+    """
+    Prüft ob BTC über seinem 4h EMA50 liegt.
+
+    Returns:
+        True wenn BTC über EMA50
+    """
+    klines = get_btc_4h_klines(limit=50)
+    if len(klines) < 50:
+        return True  # Wenn nicht genug Daten, neutral
+
+    closes = [float(k[4]) for k in klines]
+    ema50 = calculate_ema(closes, period=50)
+    current_price = closes[-1]
+
+    return current_price > ema50
+
+
+def market_gate_check() -> MarketGateResult:
+    """
+    Führt alle Market-Gate-Checks durch.
+
+    Returns:
+        MarketGateResult mit passed=True/False und Begründung
+    """
+    try:
+        btc_4h_change = _get_btc_4h_change()
+        btc_above_ema50 = _is_btc_above_ema50_4h()
+    except BinanceAPIError as e:
+        logger.error(f"Market Gate: Binance API Fehler: {e}")
+        return MarketGateResult(
+            passed=False,
+            reason=f"BINANCE_ERROR: {e}",
+            btc_4h_change_pct=0.0,
+            btc_above_ema50=False
+        )
+
+    # Check 1: BTC Drop
+    if btc_4h_change < config.BTC_FILTER_4H_DROP:
+        reason = f"BTC_4H_DROP: {btc_4h_change}%"
+        logger.warning(f"Market Gate BLOCKED: {reason}")
+        return MarketGateResult(
+            passed=False,
+            reason=reason,
+            btc_4h_change_pct=btc_4h_change,
+            btc_above_ema50=btc_above_ema50
+        )
+
+    # Check 2: BTC unter EMA50
+    if not btc_above_ema50:
+        reason = "BTC_BELOW_EMA50_4H"
+        logger.warning(f"Market Gate BLOCKED: {reason}")
+        return MarketGateResult(
+            passed=False,
+            reason=reason,
+            btc_4h_change_pct=btc_4h_change,
+            btc_above_ema50=False
+        )
+
+    # Check 3: BTC Pump (Rotation Risk)
+    if btc_4h_change > config.BTC_FILTER_4H_PUMP:
+        reason = f"BTC_4H_PUMP_ROTATION_RISK: {btc_4h_change}%"
+        logger.warning(f"Market Gate BLOCKED: {reason}")
+        return MarketGateResult(
+            passed=False,
+            reason=reason,
+            btc_4h_change_pct=btc_4h_change,
+            btc_above_ema50=btc_above_ema50
+        )
+
+    # Alles OK
+    logger.info(
+        f"Market Gate PASSED | BTC 4h: {btc_4h_change}% | "
+        f"EMA50: {'über' if btc_above_ema50 else 'unter'}"
+    )
+    return MarketGateResult(
+        passed=True,
+        reason="OK",
+        btc_4h_change_pct=btc_4h_change,
+        btc_above_ema50=btc_above_ema50
+    )

screener/screener.py

@@ -0,0 +1,238 @@
+"""
+screener.py — Stage 1: Score-System über Top 100 Coins.
+
+K.O.-Kriterien → sofortiger Ausschluss.
+Score-System → Kandidaten mit Score >= SCREENER_PASS_SCORE.
+FOMO-Schutz → Ausschluss bei +10% in 8 Kerzen.
+Max MAX_CANDIDATES_PER_CYCLE Coins durchlassen.
+"""
+
+import logging
+from dataclasses import dataclass, field
+
+import config
+from data.binance import get_klines, BinanceAPIError
+from screener.indicators import (
+    calculate_rsi,
+    calculate_ema,
+    calculate_macd,
+    calculate_atr,
+    calculate_volume_ratio,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Candidate:
+    """Ein Coin der den Screener bestanden hat."""
+    symbol: str
+    score: int
+    reasons: list[str] = field(default_factory=list)
+    price: float = 0.0
+    atr: float = 0.0
+    indicators: dict = field(default_factory=dict)
+
+
+def _extract_ohlcv(klines: list) -> dict:
+    """Extrahiert OHLCV Arrays aus Binance Kline-Daten."""
+    return {
+        "opens": [float(k[1]) for k in klines],
+        "highs": [float(k[2]) for k in klines],
+        "lows": [float(k[3]) for k in klines],
+        "closes": [float(k[4]) for k in klines],
+        "volumes": [float(k[5]) for k in klines],
+    }
+
+
+def _check_fomo(closes: list[float]) -> bool:
+    """
+    FOMO-Schutz: Preis +10% in letzten 8 Kerzen → Ausschluss.
+
+    Returns:
+        True wenn FOMO (Ausschluss)
+    """
+    if len(closes) < config.FOMO_LOOKBACK_CANDLES:
+        return False
+
+    price_8_candles_ago = closes[-(config.FOMO_LOOKBACK_CANDLES + 1)]
+    current_price = closes[-1]
+
+    if price_8_candles_ago == 0:
+        return False
+
+    change_pct = ((current_price - price_8_candles_ago) / price_8_candles_ago) * 100
+    return change_pct >= config.FOMO_PRICE_RISE_PCT
+
+
+def calculate_score(symbol: str, klines: list) -> tuple[int, list[str]]:
+    """
+    Berechnet den Score für einen Coin.
+
+    Args:
+        symbol: Coin Symbol (z.B. "ETHUSDT")
+        klines: OHLCV-Kerzen von Binance
+
+    Returns:
+        Tuple von (score, reasons_liste)
+    """
+    score = 0
+    reasons = []
+
+    ohlcv = _extract_ohlcv(klines)
+    closes = ohlcv["closes"]
+    volumes = ohlcv["volumes"]
+    highs = ohlcv["highs"]
+    lows = ohlcv["lows"]
+
+    # K.O.: Zu wenig Daten
+    if len(closes) < 50:
+        return 0, ["TOO_LITTLE_DATA"]
+
+    # FOMO-Schutz
+    if _check_fomo(closes):
+        return 0, ["FOMO_PROTECTION"]
+
+    # ── Volume Spike (3 Punkte) ──
+    vol_ratio_20 = calculate_volume_ratio(volumes, 20)
+    vol_ratio_5 = calculate_volume_ratio(volumes, 5)
+
+    if vol_ratio_20 > config.VOLUME_SPIKE_THRESHOLD and vol_ratio_5 > config.VOLUME_SPIKE_THRESHOLD:
+        score += 3
+        reasons.append(f"Volume_Spike_{vol_ratio_20:.1f}x")
+
+    # ── MACD Crossover (2 Punkte) ──
+    macd = calculate_macd(closes)
+    # Bullisches Kreuz: MACD Line kreuzt über Signal in letzten 3 Kerzen
+    if len(closes) >= 3:
+        # Historie der MACD berechnen (letzte 4 Kerzen für Kreuz-Erkennung)
+        macd_history = []
+        for i in range(max(0, len(closes) - 30), len(closes)):
+            subset = closes[:i + 1]
+            m = calculate_macd(subset)
+            macd_history.append(m)
+
+        if len(macd_history) >= 2:
+            prev = macd_history[-2]
+            curr = macd_history[-1]
+            if prev["line"] <= prev["signal"] and curr["line"] > curr["signal"]:
+                score += 2
+                reasons.append("MACD_Cross")
+
+    # ── RSI Momentum (1 Punkte) ──
+    rsi = calculate_rsi(closes)
+    if 50 <= rsi <= 65:
+        score += 1
+        reasons.append(f"RSI_Momentum_{rsi:.0f}")
+
+    # ── RSI Reversal (1 Punkte) ──
+    # RSI war < 30, in letzten 2 Kerzen nach oben durchbrochen
+    if len(closes) >= 16:
+        rsi_values = []
+        for i in range(max(0, len(closes) - 10), len(closes)):
+            subset = closes[:i + 1]
+            rsi_values.append(calculate_rsi(subset))
+
+        if len(rsi_values) >= 3:
+            if rsi_values[-3] < 30 and rsi_values[-1] > 30:
+                score += 1
+                reasons.append(f"RSI_Reversal_{rsi:.0f}")
+
+    # ── EMA Alignment (1 Punkte) ──
+    ema9 = calculate_ema(closes, 9)
+    ema21 = calculate_ema(closes, 21)
+    ema50 = calculate_ema(closes, 50)
+
+    if ema9 > ema21 > ema50:
+        score += 1
+        reasons.append("EMA_Alignment")
+
+    # ── Momentum (1 Punkte) ──
+    if len(closes) >= config.MOMENTUM_LOOKBACK_CANDLES:
+        price_8_ago = closes[-(config.MOMENTUM_LOOKBACK_CANDLES + 1)]
+        current = closes[-1]
+        if price_8_ago > 0:
+            momentum_pct = ((current - price_8_ago) / price_8_ago) * 100
+            if config.MOMENTUM_MIN_PCT <= momentum_pct <= config.MOMENTUM_MAX_PCT:
+                score += 1
+                reasons.append(f"Momentum_{momentum_pct:.1f}%")
+
+    return score, reasons
+
+
+def run_screener(
+    universe: list,
+    blacklist: set[str] | None = None
+) -> list[Candidate]:
+    """
+    Führt den Screener über das gesamte Universe aus.
+
+    Args:
+        universe: Liste von CoinInfo Objekten
+        blacklist: Set von Symbolen die ausgeschlossen sind
+
+    Returns:
+        Liste von Kandidaten mit Score >= SCREENER_PASS_SCORE
+    """
+    if blacklist is None:
+        blacklist = set()
+
+    candidates = []
+
+    for coin in universe:
+        symbol = coin.symbol
+
+        # K.O.: Blacklist
+        if symbol in blacklist:
+            continue
+
+        try:
+            klines = get_klines(symbol, interval="15m", limit=100)
+        except BinanceAPIError as e:
+            logger.debug(f"Screener: {symbol} übersprungen — {e}")
+            continue
+
+        score, reasons = calculate_score(symbol, klines)
+
+        if score >= config.SCREENER_PASS_SCORE:
+            atr = calculate_atr(
+                [float(k[2]) for k in klines],
+                [float(k[3]) for k in klines],
+                [float(k[4]) for k in klines]
+            )
+
+            candidate = Candidate(
+                symbol=symbol,
+                score=score,
+                reasons=reasons,
+                price=coin.price,
+                atr=atr,
+                indicators={
+                    "rsi": calculate_rsi([float(k[4]) for k in klines]),
+                    "macd": calculate_macd([float(k[4]) for k in klines]),
+                    "ema9": calculate_ema([float(k[4]) for k in klines], 9),
+                    "ema21": calculate_ema([float(k[4]) for k in klines], 21),
+                    "ema50": calculate_ema([float(k[4]) for k in klines], 50),
+                    "volume_ratio_20": calculate_volume_ratio(
+                        [float(k[5]) for k in klines], 20
+                    ),
+                    "volume_ratio_5": calculate_volume_ratio(
+                        [float(k[5]) for k in klines], 5
+                    ),
+                }
+            )
+            candidates.append(candidate)
+            logger.info(f"Screener: {symbol} → Score {score} | {', '.join(reasons)}")
+
+    # Sortieren nach Score absteigend
+    candidates.sort(key=lambda c: c.score, reverse=True)
+
+    # Max Kandidaten begrenzen
+    result = candidates[:config.MAX_CANDIDATES_PER_CYCLE]
+
+    logger.info(
+        f"Screener abgeschlossen: {len(universe)} Coins geprüft, "
+        f"{len(candidates)} bestanden, {len(result)} ausgewählt"
+    )
+
+    return result