agent_scoring_v2.py

"""
Agent Scoring V2 — based on real collected signals only.

Produces a composite score per agent from:
  - Benchmark performance (SWE-bench, GAIA, WebArena, HumanEval+) — 35%
  - Adoption signals (GitHub stars, downloads, VS Code installs) — 25%
  - Community sentiment (from NLP pipeline) — 20%
  - Ecosystem health (contributors, issue close rate, freshness) — 20%

Time-series: each hourly scoring run reads the latest signals and produces
one data point. The time-series builds naturally from repeated runs —
no simulation needed.
"""

import math
import json
import logging
from datetime import datetime, timezone
from collections import defaultdict
from pathlib import Path
import sys

sys.path.insert(0, str(Path(__file__).parent.parent))
from db.schema import get_connection, db

logger = logging.getLogger(__name__)


def _safe_log(x):
    if x is None or x <= 0: return 0
    return math.log10(x + 1)


def init_agent_tables():
    with db() as conn:
        conn.executescript("""
        CREATE TABLE IF NOT EXISTS agent_scores (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            agent_name TEXT NOT NULL,
            category TEXT NOT NULL,
            provider TEXT,
            score REAL,
            sentiment REAL,
            mention_count INTEGER,
            adoption REAL,
            reliability REAL,
            sub_scores TEXT,
            computed_at TEXT NOT NULL
        );
        CREATE INDEX IF NOT EXISTS idx_as_agent ON agent_scores(agent_name, category, computed_at);

        CREATE TABLE IF NOT EXISTS agent_forecasts (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            agent_name TEXT NOT NULL,
            category TEXT NOT NULL,
            step INTEGER NOT NULL,
            score REAL,
            lower_80 REAL,
            upper_80 REAL,
            forecast_time TEXT NOT NULL
        );
        """)


# Agent → provider mapping (57 agents)
PROVIDERS = {
    "Claude Code": "Anthropic", "Cursor": "Anysphere", "OpenAI Codex": "OpenAI",
    "GitHub Copilot": "GitHub", "Windsurf": "Codeium", "Gemini CLI": "Google",
    "Cline": "Cline", "Devin": "Cognition", "Replit Agent": "Replit",
    "OpenHands": "OpenHands", "SWE-agent": "Princeton",
    "Aider": "Aider", "Bolt": "StackBlitz", "Continue": "Continue",
    "Amazon Q Developer": "Amazon", "Tabnine": "Tabnine",
    "Sourcegraph Cody": "Sourcegraph", "Supermaven": "Supermaven",
    "OpenAI Deep Research": "OpenAI", "Perplexity Research": "Perplexity",
    "Manus": "Manus AI", "NotebookLM": "Google", "Kimi Researcher": "Moonshot",
    "Genspark": "Genspark", "Gemini Deep Research": "Google",
    "OpenClaw": "Anthropic", "Operator": "OpenAI",
    "Browser Use": "Browser Use", "Wingman": "Wingman", "NanoBot": "NanoBot",
    "Adept ACT-2": "Adept", "Multion": "Multion",
    "LangGraph": "LangChain", "CrewAI": "CrewAI",
    "Microsoft AutoGen": "Microsoft", "OpenAI Agents SDK": "OpenAI",
    "Claude MCP": "Anthropic", "LlamaIndex": "LlamaIndex", "PydanticAI": "Pydantic",
    "Semantic Kernel": "Microsoft", "DSPy": "Stanford", "Haystack": "deepset",
    "Composio": "Composio",
    "ChatGPT": "OpenAI", "Claude": "Anthropic", "AutoGPT": "AutoGPT", "MetaGPT": "MetaGPT",
    "Lovable": "Lovable", "v0": "Vercel", "Pieces": "Pieces",
}

# Agent → categories mapping (57 agents)
CATEGORIES = {
    "Claude Code": ["coding","copilot","swe","tool","memory","enterprise"],
    "Cursor": ["coding","copilot","enterprise"],
    "OpenAI Codex": ["coding","swe"],
    "GitHub Copilot": ["coding","copilot","enterprise"],
    "Windsurf": ["coding","copilot"],
    "Gemini CLI": ["coding","copilot"],
    "Cline": ["coding","copilot"],
    "Devin": ["coding","swe","memory"],
    "Replit Agent": ["coding"],
    "OpenHands": ["coding","swe"],
    "SWE-agent": ["swe"],
    "Aider": ["coding","swe"],
    "Bolt": ["coding","general"],
    "Continue": ["coding","copilot"],
    "Amazon Q Developer": ["coding","copilot","enterprise"],
    "Tabnine": ["coding","copilot","enterprise"],
    "Sourcegraph Cody": ["coding","copilot","enterprise"],
    "Supermaven": ["coding","copilot"],
    "OpenAI Deep Research": ["research","enterprise"],
    "Perplexity Research": ["research"],
    "Manus": ["research","general","browser"],
    "NotebookLM": ["research","data"],
    "Kimi Researcher": ["research"],
    "Genspark": ["research"],
    "Gemini Deep Research": ["research"],
    "OpenClaw": ["browser","general"],
    "Operator": ["browser","consumer"],
    "Browser Use": ["browser"],
    "Wingman": ["browser","general"],
    "NanoBot": ["browser"],
    "Adept ACT-2": ["browser"],
    "Multion": ["browser"],
    "LangGraph": ["multi"],
    "CrewAI": ["multi","enterprise"],
    "Microsoft AutoGen": ["multi","enterprise"],
    "OpenAI Agents SDK": ["multi"],
    "Claude MCP": ["multi","tool"],
    "LlamaIndex": ["multi"],
    "PydanticAI": ["multi"],
    "Semantic Kernel": ["multi","enterprise"],
    "DSPy": ["multi","research"],
    "Haystack": ["multi","enterprise"],
    "Composio": ["multi","tool"],
    "ChatGPT": ["general","consumer","data"],
    "Claude": ["general","data"],
    "AutoGPT": ["general"],
    "MetaGPT": ["general"],
    "Lovable": ["coding","general"],
    "v0": ["coding","general"],
    "Pieces": ["coding","copilot"],
}


def compute_agent_scores():
    conn = get_connection()
    init_agent_tables()
    now_ts = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")

    # Load latest signals for each agent, with carry-forward for missing data.
    # When an API call fails, the latest row may have zeros for GitHub signals.
    # We carry forward the last known good value to avoid score spikes.
    GITHUB_KEYS = {"github_stars", "github_forks", "github_open_issues", "github_watchers",
                   "github_contributors", "issue_close_rate", "days_since_update"}

    agent_signals = {}
    for r in conn.execute("""
        SELECT agent_name, signals_json FROM agent_signals_raw
        WHERE id IN (SELECT MAX(id) FROM agent_signals_raw GROUP BY agent_name)
    """).fetchall():
        latest = json.loads(r[1]) if r[1] else {}

        # If GitHub signals are missing (API failure), carry forward from previous row
        if latest.get("github_stars", 0) == 0 and any(k in latest for k in ("bench_swebench", "bench_humaneval", "sentiment_avg")):
            try:
                prev_rows = conn.execute("""
                    SELECT signals_json FROM agent_signals_raw
                    WHERE agent_name = ? AND id < (SELECT MAX(id) FROM agent_signals_raw WHERE agent_name = ?)
                    ORDER BY id DESC LIMIT 5
                """, (r[0], r[0])).fetchall()
                for prev_r in prev_rows:
                    prev = json.loads(prev_r[0]) if prev_r[0] else {}
                    if prev.get("github_stars", 0) > 0:
                        for k in GITHUB_KEYS:
                            if k in prev and latest.get(k, 0) == 0:
                                latest[k] = prev[k]
                        break
            except Exception:
                pass

        agent_signals[r[0]] = latest

    if not agent_signals:
        logger.warning("[agent_scoring_v2] no signals found — run agent_signals collector first")
        conn.close()
        return 0

    # Compute composite scores
    all_scores = {}
    for agent_name, signals in agent_signals.items():
        # ── 1. Benchmark (35%) — normalized to 0-1 ──
        bench_scores = []
        for key in ["bench_swebench", "bench_gaia", "bench_webarena", "bench_humaneval", "bench_tau"]:
            if key in signals:
                bench_scores.append(signals[key] / 100.0)
        benchmark = sum(bench_scores) / len(bench_scores) if bench_scores else 0.5  # default mid if no benchmarks

        # ── 2. Adoption (25%) — log-normalized ──
        stars = _safe_log(signals.get("github_stars", 0)) / 5.5  # 100k stars ≈ 1.0
        downloads = max(
            _safe_log(signals.get("pypi_downloads_week", 0)) / 7,
            _safe_log(signals.get("npm_downloads_week", 0)) / 7,
        )
        vscode = _safe_log(signals.get("vscode_installs", 0)) / 8  # 100M ≈ 1.0
        adoption = min(stars * 0.4 + downloads * 0.35 + vscode * 0.25, 1.0)

        # ── 3. Community sentiment (20%) ──
        sentiment = signals.get("sentiment_avg", 0.02)
        sentiment_score = max(min(sentiment * 2.5 + 0.5, 1.0), 0.0)
        mention_count = signals.get("sentiment_count", 0)

        # ── 4. Ecosystem health (20%) ──
        contributors = min(_safe_log(signals.get("github_contributors", 0)) / 3, 1.0)
        close_rate = signals.get("issue_close_rate", 0.5)
        freshness = max(1.0 - (signals.get("days_since_update", 30) / 60), 0.0)
        vscode_rating = (signals.get("vscode_rating", 3.5) - 2.0) / 3.0  # 2-5 → 0-1
        ecosystem = contributors * 0.3 + close_rate * 0.2 + freshness * 0.3 + max(min(vscode_rating, 1.0), 0.0) * 0.2

        # ── Composite ──
        composite = (
            benchmark * 0.35 +
            adoption * 0.25 +
            sentiment_score * 0.20 +
            ecosystem * 0.20
        )
        composite = max(min(composite, 1.0), 0.05)

        all_scores[agent_name] = {
            "score": composite,
            "benchmark": benchmark,
            "adoption": adoption,
            "sentiment": sentiment,
            "sentiment_score": sentiment_score,
            "ecosystem": ecosystem,
            "mention_count": mention_count,
            "sub_scores": [benchmark, adoption, ecosystem],
        }

    # Write scores for each agent in each category
    for agent_name, sc in all_scores.items():
        categories = CATEGORIES.get(agent_name, ["general"])
        provider = PROVIDERS.get(agent_name, "Unknown")

        for cat in categories:
            conn.execute("""
                INSERT INTO agent_scores
                    (agent_name, category, provider, score, sentiment,
                     mention_count, adoption, reliability, sub_scores, computed_at)
                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
            """, (
                agent_name, cat, provider,
                sc["score"], sc["sentiment"], sc["mention_count"],
                sc["adoption"], sc["ecosystem"],
                json.dumps(sc["sub_scores"]),
                now_ts,
            ))

    # Forecast: mean-reversion toward cross-sectional mean
    cs_mean = sum(s["score"] for s in all_scores.values()) / len(all_scores) if all_scores else 0.5
    for agent_name, sc in all_scores.items():
        categories = CATEGORIES.get(agent_name, ["general"])
        for cat in categories:
            # Get recent history
            hist = conn.execute("""
                SELECT score FROM agent_scores
                WHERE agent_name = ? AND category = ?
                ORDER BY computed_at DESC LIMIT 10
            """, (agent_name, cat)).fetchall()
            scores = [r[0] for r in hist if r[0] is not None]

            if len(scores) < 2:
                base = sc["score"]
                vol = 0.015
            else:
                base = scores[0]
                diffs = [scores[i] - scores[i+1] for i in range(len(scores)-1)]
                vol = max(sum(abs(d) for d in diffs) / len(diffs), 0.008)

            for step in range(1, 73):
                # Mean-revert toward cross-sectional mean
                fc = base + 0.003 * (cs_mean - base) * step
                fc = max(0.05, min(0.98, fc))
                spread = vol * math.sqrt(step) * 1.28

                conn.execute("""
                    INSERT OR REPLACE INTO agent_forecasts
                        (agent_name, category, step, score, lower_80, upper_80, forecast_time)
                    VALUES (?, ?, ?, ?, ?, ?, ?)
                """, (agent_name, cat, step, fc, fc - spread, fc + spread, now_ts))

    conn.commit()
    conn.close()
    logger.info("[agent_scoring_v2] scored %d agents", len(all_scores))
    return len(all_scores)


if __name__ == "__main__":
    logging.basicConfig(level=logging.INFO,
                        format="%(asctime)s [%(levelname)s] %(name)s — %(message)s")
    n = compute_agent_scores()
    print(f"Scored {n} agents")