feat: initial commit — polymarket-bot source + CI/CD pipeline

bot/metrics/tracker.py

@@ -0,0 +1,130 @@
+"""
+Metrics Tracker — Computes trading performance metrics.
+
+Key metrics tracked:
+- P&L (cumulative and daily)
+- Sharpe Ratio (annualized)
+- Win Rate
+- Calibration Score (how accurate our probability estimates are)
+- Max Drawdown
+- Average Edge realized
+"""
+import logging
+import math
+from datetime import datetime, UTC
+from typing import Optional
+
+from bot.executor.paper import Trade
+from bot.data.db import Database
+
+log = logging.getLogger(__name__)
+
+
+class MetricsTracker:
+    def __init__(self, db: Database) -> None:
+        self._db = db
+        self._trades: list[Trade] = []
+        self._daily_returns: list[float] = []
+
+    async def record_trade(self, trade: Trade) -> None:
+        self._trades.append(trade)
+        await self._db.save_trade(trade)
+        log.info("Trade recorded. Total trades: %d", len(self._trades))
+
+    async def update_daily_summary(self) -> None:
+        """Compute and store daily metrics snapshot."""
+        if not self._trades:
+            return
+
+        metrics = self.compute_metrics()
+        await self._db.save_daily_metrics(metrics)
+
+        log.info(
+            "Daily metrics | Trades: %d | P&L: $%.2f | Win: %.1f%% | Sharpe: %.2f",
+            metrics["total_trades"],
+            metrics["total_pnl"],
+            metrics["win_rate"] * 100,
+            metrics["sharpe_ratio"],
+        )
+
+    def compute_metrics(self) -> dict:
+        if not self._trades:
+            return self._empty_metrics()
+
+        trades = self._trades
+        n = len(trades)
+
+        # Total cost deployed
+        total_deployed = sum(t.net_cost for t in trades)
+        total_fees = sum(t.fee_usdc for t in trades)
+
+        # Win rate (trades where we had positive edge — in paper mode we estimate)
+        # A trade "wins" if entry_price < 0.5 (buying undervalued token)
+        wins = sum(1 for t in trades if t.entry_price < 0.5)
+        win_rate = wins / n if n > 0 else 0
+
+        # Estimated P&L (paper — based on edge captured)
+        # Edge = (estimated_prob - entry_price) * shares
+        total_pnl = sum(
+            (0.5 - t.entry_price) * t.shares - t.fee_usdc
+            for t in trades
+        )
+
+        # Average edge per trade
+        avg_edge = total_pnl / total_deployed if total_deployed > 0 else 0
+
+        # Sharpe ratio (simplified — daily returns not yet available in paper mode)
+        # Will improve once markets resolve and we have actual returns
+        sharpe = self._compute_sharpe()
+
+        # Calibration score (Brier score based)
+        # Perfect calibration = 1.0, random = 0.0
+        calibration = 1 - (2 * abs(avg_edge))  # Simplified until markets resolve
+
+        return {
+            "timestamp": datetime.now(UTC),
+            "total_trades": n,
+            "total_deployed": total_deployed,
+            "total_fees": total_fees,
+            "total_pnl": total_pnl,
+            "win_rate": win_rate,
+            "avg_edge": avg_edge,
+            "sharpe_ratio": sharpe,
+            "calibration_score": max(0, min(1, calibration)),
+            "paper_mode": True,
+        }
+
+    def _compute_sharpe(self) -> float:
+        """Annualized Sharpe ratio from daily returns."""
+        if len(self._daily_returns) < 2:
+            return 0.0
+        mean_r = sum(self._daily_returns) / len(self._daily_returns)
+        variance = sum((r - mean_r) ** 2 for r in self._daily_returns) / len(self._daily_returns)
+        std_r = math.sqrt(variance) if variance > 0 else 1e-9
+        return (mean_r / std_r) * math.sqrt(365)  # Annualize
+
+    def check_promotion_thresholds(self) -> tuple[bool, dict]:
+        """Check if metrics qualify for real money trading."""
+        metrics = self.compute_metrics()
+        checks = {
+            "sharpe_ratio": (metrics["sharpe_ratio"], 0.5, metrics["sharpe_ratio"] >= 0.5),
+            "win_rate": (metrics["win_rate"], 0.52, metrics["win_rate"] >= 0.52),
+            "calibration_score": (metrics["calibration_score"], 0.7, metrics["calibration_score"] >= 0.7),
+            "min_trades": (metrics["total_trades"], 50, metrics["total_trades"] >= 50),
+        }
+        all_pass = all(v[2] for v in checks.values())
+        return all_pass, checks
+
+    def _empty_metrics(self) -> dict:
+        return {
+            "timestamp": datetime.now(UTC),
+            "total_trades": 0,
+            "total_deployed": 0,
+            "total_fees": 0,
+            "total_pnl": 0,
+            "win_rate": 0,
+            "avg_edge": 0,
+            "sharpe_ratio": 0,
+            "calibration_score": 0,
+            "paper_mode": True,
+        }