# MidasBot 🪙

Bot de trading/arbitrage crypto **assisté par IA**, conçu pour tourner en **dry-run** (simulation, aucun risque financier) avant tout passage en réel.

- **Moteur** : [Freqtrade](https://www.freqtrade.io/) (backtesting, dry-run, dashboard FreqUI, connecteurs CEX via ccxt).
- **IA** : Claude (analyse de marché) via l'**abonnement** Claude Code en mode headless — **pas** l'API facturée au token.
- **Arbitrage** : module séparé (CEX d'abord, DEX ensuite).

> ⚠️ **Statut : dry-run.** Aucune clé d'échange n'est requise. Le passage en trading réel est une décision explicite et séparée.

## Architecture

```
ai_analyzer  ──(biais de marché)──▶  Redis  ──(lecture)──▶  AiBiasStrategy (Freqtrade)
     │                                                             │
     └── claude -p (abonnement) + MCP TradingView          dry-run + FreqUI (localhost:8080)

arbitrage/   ──(scan d'écarts inter-CEX via ccxt, dry-run)──▶  logs
dashboard/   ──(insights IA + lien FreqUI)
```

## Prérequis

- **Docker** + Docker Compose (le moteur tourne en conteneurs ; Python local n'est pas requis).
- **Claude Code** installé et connecté à ton abonnement (`claude login`).

## Démarrage rapide

```bash
# 1. Configurer les secrets
cp .env.example .env
# (puis générer des secrets FreqUI : openssl rand -hex 32 pour JWT_SECRET_KEY)

# 2. Lancer le socle (Freqtrade dry-run AiBiasStrategy + Redis + dashboard)
docker compose up -d            # freqtrade + redis + dashboard

# 3. Ouvrir les interfaces
open http://127.0.0.1:8080      # FreqUI (positions, P&L, trades)
open http://127.0.0.1:8500      # Dashboard « Insights IA »
```

## Services & ports

| Service | Port (hôte) | Rôle | Profil compose |
|---------|-------------|------|----------------|
| `freqtrade` | 8080 | Moteur dry-run + FreqUI | défaut |
| `dashboard` | 8500 | Panneau Insights IA | défaut |
| `redis` | 6380 | Bus de signaux | défaut |
| `ai-analyzer` | — | Analyse Claude → biais Redis | `ai` |
| `arbitrage` | — | Scan d'écarts inter-CEX (dry-run) | `arb` |

## Lancer la couche IA (analyzer)

L'analyzer interroge Claude via ton **abonnement** (pas l'API). Deux options :

**A. En conteneur** (orchestration complète) :
```bash
claude setup-token                       # → coller dans .env (CLAUDE_CODE_OAUTH_TOKEN)
docker compose --profile ai up -d --build ai-analyzer
```

**B. En local, à la main** (rapide pour tester, utilise ton `claude` déjà connecté) :
```bash
python3 -m venv .venv && .venv/bin/pip install -r ai_analyzer/requirements.txt
cd ai_analyzer
REDIS_URL=redis://localhost:6380/0 ../.venv/bin/python analyzer.py --once
```

**C. En local, automatique toutes les heures (recommandé)** — via `launchd`, sans
manipuler de token (utilise ton `claude` hôte qui gère le rafraîchissement) :
```bash
cp scripts/com.midasbot.analyzer.plist ~/Library/LaunchAgents/
launchctl load -w ~/Library/LaunchAgents/com.midasbot.analyzer.plist   # 1er run immédiat
tail -f logs/analyzer.log                                              # suivre
```
Gestion : `launchctl list | grep midasbot` (état) · `launchctl unload ~/Library/LaunchAgents/com.midasbot.analyzer.plist` (arrêter).
Le script lancé est `scripts/run_analyzer.sh` (paires, modèle, intervalle modifiables dedans).

> Cadence basse par défaut (1 cycle/h, 1 seul appel Claude couvrant toutes les paires)
> pour ménager les limites d'usage de l'abonnement.

Chaque cycle **historise** les biais dans `freqtrade/user_data/ai_bias_history/<PAIR>.csv`
(horodaté). En **live/dry-run** la stratégie lit le biais courant (Redis) ; en **backtest**
elle lit l'historique et associe à chaque bougie le biais valide à cette date (`merge_asof`).

## Backtester l'IA (vrai backtest)

L'historique s'accumule au fil des cycles. Pour amorcer un backtest immédiatement, génère
des biais passés avec le **backfill** (⚠️ 1 appel Claude par pas de temps — consomme le quota) :

```bash
cd ai_analyzer
# ~180 appels pour 6 mois en cadence 24 h. Ajuste --step-hours selon ton quota.
REDIS_URL=redis://localhost:6380/0 ../.venv/bin/python backfill.py \
  --start 20260101 --step-hours 24
```
Puis lance le backtest qui lira cet historique :
```bash
docker compose run --rm freqtrade backtesting \
  --strategy AiBiasStrategy --timeframe 1h --timerange 20260101-
```

## Lancer le scanner d'arbitrage (dry-run)

```bash
docker compose --profile arb up -d --build arbitrage
docker compose logs -f arbitrage
```

## Phases

| Phase | Contenu | Statut |
|-------|---------|--------|
| 1 | Freqtrade dry-run + FreqUI | ✅ |
| 2 | Backtesting | ✅ |
| 3 | Couche IA (Claude + MCP TradingView) | ✅ |
| 4 | Arbitrage CEX (dry-run) | ✅ |
| 5 | Dashboard insights IA | ✅ |

À venir : MCP TradingView branché par défaut, biais historiques pour backtester l'IA, connecteur DEX, passage en réel (clés exchange + garde-fous).

Plan détaillé : voir `~/.claude/plans/le-but-du-jeu-streamed-journal.md`.

## Sécurité

- `.env` n'est jamais commité (cf. `.gitignore`).
- `CLAUDE_CODE_OAUTH_TOKEN` (abonnement) — **ne pas** définir `ANTHROPIC_API_KEY` (basculerait sur la facturation au token).
- Ports exposés sur `127.0.0.1` uniquement.