codeforces-mcp-avinash 0.1.0__tar.gz

codeforces_mcp_avinash-0.1.0/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.5
+Name: codeforces-mcp-avinash
+Version: 0.1.0
+Summary: Codeforces MCP server for competitive programming, upsolving, and automated stress testing
+Project-URL: Repository, https://github.com/avinash111921/codeforces-mcp
+Author-email: Avinash Verma <avinash1921avi@gmail.com>
+License: MIT
+Requires-Python: >=3.12
+Requires-Dist: beautifulsoup4>=4.12.3
+Requires-Dist: curl-cffi>=0.9.0
+Requires-Dist: diskcache>=5.6.3
+Requires-Dist: httpx>=0.28.0
+Requires-Dist: mcp[cli]>=1.4.0
+Requires-Dist: pydantic>=2.10.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.25.0; extra == 'dev'
+Requires-Dist: pytest>=8.3.0; extra == 'dev'
+Requires-Dist: respx>=0.22.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Codeforces MCP Server
+
+A Model Context Protocol (MCP) server for Codeforces competitive programming. This server enables AI coding assistants (like Claude, Cursor, and Roo Code / Cline) to autonomously fetch problem statements, analyze your submission history, recommend upsolving targets, and run automated local stress tests.
+
+## Features
+- **Profile & Stats**: Fetch live user ratings, ranks, and recent verdict breakdowns.
+- **Problem Scraping**: Extracts full problem descriptions and exact sample test cases.
+- **Local Sandbox**: Compiles and executes C++ or Python solutions locally against official sample inputs.
+- **Automated Stress Testing**: Isolates minimal failing test cases by running your optimized code against a brute-force script and a random generator.
+
+## Installation 
+Add this to your `cline_mcp_settings.json` or Cursor MCP settings:
+```json
+{
+  "mcpServers": {
+    "codeforces-mcp": {
+      "command": "uvx",
+      "args": ["codeforces-mcp"]
+    }
+  }
+}
+
+## License
+MIT
+
+---
+mcp-name: io.github.avinash111921/codeforces-mcp

codeforces_mcp_avinash-0.1.0/README.md

@@ -0,0 +1,27 @@
+# Codeforces MCP Server
+
+A Model Context Protocol (MCP) server for Codeforces competitive programming. This server enables AI coding assistants (like Claude, Cursor, and Roo Code / Cline) to autonomously fetch problem statements, analyze your submission history, recommend upsolving targets, and run automated local stress tests.
+
+## Features
+- **Profile & Stats**: Fetch live user ratings, ranks, and recent verdict breakdowns.
+- **Problem Scraping**: Extracts full problem descriptions and exact sample test cases.
+- **Local Sandbox**: Compiles and executes C++ or Python solutions locally against official sample inputs.
+- **Automated Stress Testing**: Isolates minimal failing test cases by running your optimized code against a brute-force script and a random generator.
+
+## Installation 
+Add this to your `cline_mcp_settings.json` or Cursor MCP settings:
+```json
+{
+  "mcpServers": {
+    "codeforces-mcp": {
+      "command": "uvx",
+      "args": ["codeforces-mcp"]
+    }
+  }
+}
+
+## License
+MIT
+
+---
+mcp-name: io.github.avinash111921/codeforces-mcp

codeforces_mcp_avinash-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "codeforces-mcp-avinash" 
+version = "0.1.0"
+description = "Codeforces MCP server for competitive programming, upsolving, and automated stress testing"
+readme = "README.md"
+requires-python = ">=3.12"
+authors = [{ name = "Avinash Verma", email = "avinash1921avi@gmail.com" }]
+urls = { Repository = "https://github.com/avinash111921/codeforces-mcp" }
+license = { text = "MIT" }
+dependencies = [
+    "mcp[cli]>=1.4.0",
+    "httpx>=0.28.0",
+    "curl-cffi>=0.9.0",
+    "beautifulsoup4>=4.12.3",
+    "pydantic>=2.10.0",
+    "diskcache>=5.6.3",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.3.0",
+    "pytest-asyncio>=0.25.0",
+    "respx>=0.22.0",
+]
+
+[project.scripts]
+codeforces-mcp = "codeforces_mcp.server:main"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/codeforces_mcp"]

codeforces_mcp_avinash-0.1.0/src/codeforces_mcp/client.py

@@ -0,0 +1,64 @@
+import asyncio
+import time
+from pathlib import Path
+from typing import Any
+import httpx
+from diskcache import Cache
+
+CACHE_DIR = Path.home() / ".cache" / "codeforces-mcp"
+
+
+class CodeforcesClient:
+    BASE_URL = "https://codeforces.com/api"
+
+    def __init__(self, rate_limit_delay: float = 2.1) -> None:
+        self.rate_limit_delay = rate_limit_delay
+        self._lock = asyncio.Lock()
+        self._last_call_time = 0.0
+        self.cache = Cache(str(CACHE_DIR))
+        self._http = httpx.AsyncClient(timeout=15.0)
+
+    async def _request(self, endpoint: str, params: dict[str, Any] | None = None) -> Any:
+        async with self._lock:
+            elapsed = time.monotonic() - self._last_call_time
+            if elapsed < self.rate_limit_delay:
+                await asyncio.sleep(self.rate_limit_delay - elapsed)
+
+            url = f"{self.BASE_URL}/{endpoint}"
+            response = await self._http.get(url, params=params)
+            self._last_call_time = time.monotonic()
+
+            response.raise_for_status()
+            data = response.json()
+            if data.get("status") != "OK":
+                raise RuntimeError(data.get("comment", "Unknown Codeforces API error"))
+            return data["result"]
+
+    async def get_user_info(self, handle: str) -> dict[str, Any]:
+        result = await self._request("user.info", {"handles": handle})
+        return result[0]
+
+    async def get_user_submissions(self, handle: str, count: int = 50) -> list[dict[str, Any]]:
+        return await self._request("user.status", {"handle": handle, "from": 1, "count": count})
+
+    async def get_problemset(self) -> dict[str, Any]:
+        cached = self.cache.get("problemset_all")
+        if cached is not None:
+            return cached
+        result = await self._request("problemset.problems")
+        # Cache the 10,000+ problem catalog for 1 hour
+        self.cache.set("problemset_all", result, expire=3600)
+        return result
+
+    async def get_upcoming_contests(self) -> list[dict[str, Any]]:
+        cached = self.cache.get("upcoming_contests")
+        if cached is not None:
+            return cached
+        contests = await self._request("contest.list", {"gym": "false"})
+        upcoming = [c for c in contests if c.get("phase") == "BEFORE"]
+        upcoming.sort(key=lambda x: x.get("startTimeSeconds", 0))
+        self.cache.set("upcoming_contests", upcoming, expire=900)
+        return upcoming
+
+    async def close(self) -> None:
+        await self._http.aclose()

codeforces_mcp_avinash-0.1.0/src/codeforces_mcp/sandbox.py

@@ -0,0 +1,116 @@
+import subprocess
+import tempfile
+import time
+from pathlib import Path
+from typing import Any
+
+
+def compile_if_cpp(source_path: Path, work_dir: Path) -> list[str]:
+    if source_path.suffix == ".cpp":
+        exe_path = work_dir / ("sol.exe" if Path.cwd().drive else "sol.out")
+        cmd = ["g++", "-O2", "-std=c++20", str(source_path), "-o", str(exe_path)]
+        res = subprocess.run(cmd, capture_output=True, text=True, timeout=15)
+        if res.returncode != 0:
+            raise RuntimeError(f"Compilation Error in {source_path.name}:\n{res.stderr}")
+        return [str(exe_path)]
+    elif source_path.suffix == ".py":
+        return ["python", str(source_path)]
+    raise ValueError(f"Unsupported file extension: {source_path.suffix}. Use .cpp or .py")
+
+
+def execute_cmd(cmd: list[str], stdin_data: str, timeout_sec: float = 2.0) -> dict[str, Any]:
+    start = time.perf_counter()
+    try:
+        proc = subprocess.run(
+            cmd,
+            input=stdin_data,
+            capture_output=True,
+            text=True,
+            timeout=timeout_sec,
+        )
+        elapsed_ms = round((time.perf_counter() - start) * 1000, 2)
+        return {
+            "verdict": "OK" if proc.returncode == 0 else "RTE",
+            "stdout": proc.stdout.strip(),
+            "stderr": proc.stderr.strip(),
+            "time_ms": elapsed_ms,
+        }
+    except subprocess.TimeoutExpired:
+        return {"verdict": "TLE", "stdout": "", "stderr": "Time Limit Exceeded", "time_ms": timeout_sec * 1000}
+
+
+def run_samples(source_file: str, samples: list[dict[str, str]]) -> dict[str, Any]:
+    src = Path(source_file).resolve()
+    if not src.exists():
+        raise FileNotFoundError(f"File not found: {src}")
+
+    with tempfile.TemporaryDirectory() as tmp:
+        cmd = compile_if_cpp(src, Path(tmp))
+        results = []
+        all_passed = True
+
+        for idx, sample in enumerate(samples, start=1):
+            run_res = execute_cmd(cmd, sample["input"])
+            expected = sample["output"].strip()
+            actual = run_res["stdout"]
+            passed = (run_res["verdict"] == "OK") and (actual == expected)
+            if not passed:
+                all_passed = False
+
+            results.append({
+                "test_case": idx,
+                "status": "PASSED" if passed else (run_res["verdict"] if run_res["verdict"] != "OK" else "WA"),
+                "time_ms": run_res["time_ms"],
+                "input": sample["input"],
+                "expected_output": expected,
+                "actual_output": actual,
+            })
+
+        return {"all_passed": all_passed, "results": results}
+
+
+def run_stress_test(
+    optimal_file: str,
+    brute_file: str,
+    generator_file: str,
+    iterations: int = 100,
+) -> dict[str, Any]:
+    opt_path = Path(optimal_file).resolve()
+    brute_path = Path(brute_file).resolve()
+    gen_path = Path(generator_file).resolve()
+
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp_dir = Path(tmp)
+        opt_cmd = compile_if_cpp(opt_path, tmp_dir / "opt") if opt_path.suffix == ".cpp" else ["python", str(opt_path)]
+        if opt_path.suffix == ".cpp":
+            (tmp_dir / "opt").mkdir(exist_ok=True)
+            opt_cmd = compile_if_cpp(opt_path, tmp_dir / "opt")
+
+        if brute_path.suffix == ".cpp":
+            (tmp_dir / "brute").mkdir(exist_ok=True)
+            brute_cmd = compile_if_cpp(brute_path, tmp_dir / "brute")
+        else:
+            brute_cmd = ["python", str(brute_path)]
+
+        gen_cmd = ["python", str(gen_path)]
+
+        for i in range(1, min(iterations, 500) + 1):
+            gen_res = execute_cmd(gen_cmd, str(i))
+            if gen_res["verdict"] != "OK":
+                raise RuntimeError(f"Generator crashed on iteration {i}: {gen_res['stderr']}")
+
+            test_input = gen_res["stdout"]
+            opt_res = execute_cmd(opt_cmd, test_input)
+            brute_res = execute_cmd(brute_cmd, test_input)
+
+            if opt_res["verdict"] != "OK" or opt_res["stdout"] != brute_res["stdout"]:
+                return {
+                    "found_counterexample": True,
+                    "iteration": i,
+                    "failing_input": test_input,
+                    "expected_brute_output": brute_res["stdout"],
+                    "actual_optimal_output": opt_res["stdout"],
+                    "optimal_verdict": opt_res["verdict"],
+                }
+
+        return {"found_counterexample": False, "iterations_tested": iterations}

codeforces_mcp_avinash-0.1.0/src/codeforces_mcp/scraper.py

@@ -0,0 +1,69 @@
+import asyncio
+from typing import Any
+from bs4 import BeautifulSoup
+from curl_cffi.requests import AsyncSession
+from diskcache import Cache
+from .client import CACHE_DIR
+
+scraper_cache = Cache(str(CACHE_DIR / "problems"))
+
+
+def _parse_problem_html(html: str, contest_id: int, index: str) -> dict[str, Any]:
+    soup = BeautifulSoup(html, "html.parser")
+    statement = soup.select_one("div.problem-statement")
+    if not statement:
+        raise ValueError(f"Could not locate problem statement for {contest_id}{index}.")
+
+    header = statement.select_one("div.header")
+    title = header.select_one("div.title").get_text(strip=True) if header else f"{contest_id}{index}"
+    time_limit = (
+        header.select_one("div.time-limit").get_text(separator=" ", strip=True)
+        if header else "Unknown"
+    )
+    memory_limit = (
+        header.select_one("div.memory-limit").get_text(separator=" ", strip=True)
+        if header else "Unknown"
+    )
+
+    # Extract sample test cases preserving exact newlines
+    samples: list[dict[str, str]] = []
+    inputs = statement.select("div.sample-test div.input pre")
+    outputs = statement.select("div.sample-test div.output pre")
+
+    for inp, out in zip(inputs, outputs):
+        in_lines = [div.get_text() for div in inp.select("div.test-example-line")]
+        in_text = "\n".join(in_lines) if in_lines else inp.get_text("\n", strip=True)
+        out_text = out.get_text("\n", strip=True)
+        samples.append({"input": in_text.strip(), "output": out_text.strip()})
+
+    # Extract body paragraphs
+    body_parts = []
+    for div in statement.find_all("div", recursive=False):
+        classes = div.get("class") or []
+        if "header" not in classes and "sample-test" not in classes:
+            body_parts.append(div.get_text("\n", strip=True))
+
+    return {
+        "problem_id": f"{contest_id}{index.upper()}",
+        "title": title,
+        "time_limit": time_limit,
+        "memory_limit": memory_limit,
+        "description": "\n\n".join(body_parts),
+        "samples": samples,
+    }
+
+
+async def fetch_problem_statement(contest_id: int, index: str) -> dict[str, Any]:
+    key = f"prob_{contest_id}_{index.upper()}"
+    cached = scraper_cache.get(key)
+    if cached is not None:
+        return cached
+
+    url = f"https://codeforces.com/contest/{contest_id}/problem/{index.upper()}"
+    async with AsyncSession(impersonate="chrome124", timeout=15) as session:
+        response = await session.get(url)
+        if response.status_code != 200:
+            raise RuntimeError(f"Failed to fetch problem page (HTTP {response.status_code})")
+        parsed = await asyncio.to_thread(_parse_problem_html, response.text, contest_id, index)
+        scraper_cache.set(key, parsed)
+        return parsed

codeforces_mcp_avinash-0.1.0/src/codeforces_mcp/server.py

@@ -0,0 +1,114 @@
+from typing import Any
+from mcp.server.mcpserver import MCPServer
+from mcp.types import ToolAnnotations
+from .client import CodeforcesClient
+from .scraper import fetch_problem_statement
+from .sandbox import run_samples, run_stress_test
+
+mcp = MCPServer("Codeforces-MCP")
+cf_client = CodeforcesClient()
+
+READ_ONLY = ToolAnnotations(readOnlyHint=True, destructiveHint=False, idempotentHint=True)
+LOCAL_EXEC = ToolAnnotations(readOnlyHint=False, destructiveHint=False)
+
+
+@mcp.tool(annotations=READ_ONLY)
+async def get_user_profile(handle: str) -> dict[str, Any]:
+    """Fetch a Codeforces user's current rating, max rating, rank, and recent verdict breakdown."""
+    info = await cf_client.get_user_info(handle)
+    submissions = await cf_client.get_user_submissions(handle, count=100)
+
+    verdicts: dict[str, int] = {}
+    weak_tags: dict[str, int] = {}
+
+    for sub in submissions:
+        v = sub.get("verdict", "UNKNOWN")
+        verdicts[v] = verdicts.get(v, 0) + 1
+        if v != "OK":
+            for tag in sub.get("problem", {}).get("tags", []):
+                weak_tags[tag] = weak_tags.get(tag, 0) + 1
+
+    top_weak_tags = sorted(weak_tags.items(), key=lambda x: x[1], reverse=True)[:5]
+
+    return {
+        "handle": info.get("handle"),
+        "rating": info.get("rating", "Unrated"),
+        "maxRating": info.get("maxRating", "Unrated"),
+        "rank": info.get("rank", "Unrated"),
+        "recent_100_verdicts": verdicts,
+        "most_failed_tags_recently": [t[0] for t in top_weak_tags],
+    }
+
+
+@mcp.tool(annotations=READ_ONLY)
+async def get_problem(contest_id: int, index: str) -> dict[str, Any]:
+    """Fetch the full problem statement, constraints, and sample test cases for a Codeforces problem."""
+    return await fetch_problem_statement(contest_id, index)
+
+
+@mcp.tool(annotations=READ_ONLY)
+async def recommend_upsolve_problems(
+    handle: str,
+    tag: str | None = None,
+    min_rating: int = 1600,
+    max_rating: int = 1900,
+    limit: int = 5,
+) -> list[dict[str, Any]]:
+    """Recommend unsolved Codeforces problems filtered by rating range and optional topic tag."""
+    subs = await cf_client.get_user_submissions(handle, count=500)
+    solved = {
+        f"{s['problem'].get('contestId')}{s['problem'].get('index')}"
+        for s in subs
+        if s.get("verdict") == "OK" and "problem" in s
+    }
+
+    catalog = await cf_client.get_problemset()
+    recommendations = []
+
+    for prob in catalog.get("problems", []):
+        pid = f"{prob.get('contestId')}{prob.get('index')}"
+        rating = prob.get("rating", 0)
+        tags = prob.get("tags", [])
+
+        if pid in solved or not (min_rating <= rating <= max_rating):
+            continue
+        if tag and tag.lower() not in [t.lower() for t in tags]:
+            continue
+
+        recommendations.append({
+            "problem_id": pid,
+            "name": prob.get("name"),
+            "rating": rating,
+            "tags": tags,
+            "url": f"https://codeforces.com/contest/{prob.get('contestId')}/problem/{prob.get('index')}",
+        })
+        if len(recommendations) >= limit:
+            break
+
+    return recommendations
+
+
+@mcp.tool(annotations=LOCAL_EXEC)
+async def test_local_solution(source_file: str, contest_id: int, index: str) -> dict[str, Any]:
+    """Compile and run a local .cpp or .py file against official Codeforces sample test cases."""
+    problem = await fetch_problem_statement(contest_id, index)
+    return run_samples(source_file, problem["samples"])
+
+
+@mcp.tool(annotations=LOCAL_EXEC)
+async def find_counterexample(
+    optimal_file: str,
+    brute_file: str,
+    generator_file: str,
+    iterations: int = 100,
+) -> dict[str, Any]:
+    """Stress test an optimal solution against a brute-force solution using a generator script."""
+    return run_stress_test(optimal_file, brute_file, generator_file, iterations)
+
+
+def main() -> None:
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()