mcp-demand-radar 0.1.0__tar.gz

mcp_demand_radar-0.1.0/.gitignore

@@ -0,0 +1,44 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+# Packaging
+build/
+dist/
+*.egg-info/
+.eggs/
+wheels/
+
+# Environnements virtuels
+.venv/
+venv/
+env/
+
+# Tests et outils
+.pytest_cache/
+.coverage
+htmlcov/
+.mypy_cache/
+.ruff_cache/
+.tox/
+
+# Secrets et configuration locale
+.env
+.env.*
+*.pem
+*.key
+
+# Radar : configuration réelle et sorties (seul radar.example.toml est versionné)
+radar.toml
+*.csv
+rapport*.html
+
+# Éditeurs et système
+.vscode/
+.idea/
+.DS_Store
+Thumbs.db
+radar-data/
+radar-out/

mcp_demand_radar-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jérémie
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mcp_demand_radar-0.1.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.5
+Name: mcp-demand-radar
+Version: 0.1.0
+Summary: Track GitHub demand for MCP servers and find the gaps nobody fills yet.
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,github,market-research,mcp
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Description-Content-Type: text/markdown
+
+# mcp-demand-radar
+
+Track which MCP servers GitHub users are asking for, and which of those requests nobody has built yet.
+
+Standard library only, Python 3.11+, no dependencies.
+
+## Install
+
+```bash
+pip install mcp-demand-radar
+```
+
+The command it installs is `mcp-radar`.
+
+## Try it without a token or network
+
+```bash
+mcp-radar scan --demo
+mcp-radar gaps --demo
+mcp-radar report --demo --out radar-out
+```
+
+Demo mode uses fictional offline data.
+
+## Real use
+
+```bash
+export GITHUB_TOKEN=...        # optional but recommended (5,000 requests/hour instead of 60)
+cp radar.example.toml radar.toml   # then adapt your categories
+mcp-radar report
+```
+
+`radar.toml` is read from the current directory (or `--config path`). Keep it out of version control; the package only ships a neutral `radar.example.toml`.
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `mcp-radar scan` | Popular repositories for each configured category (most starred MCP servers, newcomers…). |
+| `mcp-radar demand` | Open GitHub issues asking for an MCP server, ranked by reactions. |
+| `mcp-radar gaps` | For each request, counts existing MCP servers with ≥10 stars; score = reactions / (1 + that count). |
+| `mcp-radar report` | Runs everything, writes `report.html` and `report.csv`, stores a dated snapshot in `data_dir` and shows star gains since the previous snapshot. |
+
+All commands accept `--config`, `--demo` and `--json` (`report` also `--out`).
+
+## Configuration
+
+See `radar.example.toml`: custom categories (`{days30}` / `{days90}` expand to dates), demand queries, minimum reactions, stopwords used to extract a request's subject.
+
+## Using it from Claude Code / Claude Desktop
+
+This is a CLI, not an MCP server. In Claude Code, just ask: "run `mcp-radar gaps` and summarise the top 5 opportunities". Claude Desktop cannot run shell commands; open `report.html` in a browser instead.
+
+## Development
+
+```bash
+pip install -e ".[test]"
+pytest        # offline, uses simulated GitHub responses
+```
+
+## License
+
+MIT

mcp_demand_radar-0.1.0/README.md

@@ -0,0 +1,63 @@
+# mcp-demand-radar
+
+Track which MCP servers GitHub users are asking for, and which of those requests nobody has built yet.
+
+Standard library only, Python 3.11+, no dependencies.
+
+## Install
+
+```bash
+pip install mcp-demand-radar
+```
+
+The command it installs is `mcp-radar`.
+
+## Try it without a token or network
+
+```bash
+mcp-radar scan --demo
+mcp-radar gaps --demo
+mcp-radar report --demo --out radar-out
+```
+
+Demo mode uses fictional offline data.
+
+## Real use
+
+```bash
+export GITHUB_TOKEN=...        # optional but recommended (5,000 requests/hour instead of 60)
+cp radar.example.toml radar.toml   # then adapt your categories
+mcp-radar report
+```
+
+`radar.toml` is read from the current directory (or `--config path`). Keep it out of version control; the package only ships a neutral `radar.example.toml`.
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `mcp-radar scan` | Popular repositories for each configured category (most starred MCP servers, newcomers…). |
+| `mcp-radar demand` | Open GitHub issues asking for an MCP server, ranked by reactions. |
+| `mcp-radar gaps` | For each request, counts existing MCP servers with ≥10 stars; score = reactions / (1 + that count). |
+| `mcp-radar report` | Runs everything, writes `report.html` and `report.csv`, stores a dated snapshot in `data_dir` and shows star gains since the previous snapshot. |
+
+All commands accept `--config`, `--demo` and `--json` (`report` also `--out`).
+
+## Configuration
+
+See `radar.example.toml`: custom categories (`{days30}` / `{days90}` expand to dates), demand queries, minimum reactions, stopwords used to extract a request's subject.
+
+## Using it from Claude Code / Claude Desktop
+
+This is a CLI, not an MCP server. In Claude Code, just ask: "run `mcp-radar gaps` and summarise the top 5 opportunities". Claude Desktop cannot run shell commands; open `report.html` in a browser instead.
+
+## Development
+
+```bash
+pip install -e ".[test]"
+pytest        # offline, uses simulated GitHub responses
+```
+
+## License
+
+MIT

mcp_demand_radar-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "mcp-demand-radar"
+version = "0.1.0"
+description = "Track GitHub demand for MCP servers and find the gaps nobody fills yet."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+dependencies = []
+keywords = ["mcp", "github", "market-research", "cli"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Environment :: Console",
+]
+
+[project.optional-dependencies]
+test = ["pytest"]
+
+[project.scripts]
+mcp-radar = "mcp_radar.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mcp_radar"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src", "tests", "README.md", "LICENSE", "radar.example.toml"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

mcp_demand_radar-0.1.0/radar.example.toml

@@ -0,0 +1,26 @@
+# Example configuration. Copy to radar.toml (never committed) and adapt.
+# Categories here are deliberately generic.
+
+[radar]
+data_dir = "radar-data"   # where snapshots are stored
+top = 20                  # repositories per category
+
+[[categories]]
+id = "mcp_top"
+label = "Most starred MCP servers"
+query = "topic:mcp-server"
+
+[[categories]]
+id = "mcp_new"
+label = "New MCP servers (last 90 days)"
+query = "mcp server in:name,description created:>{days90}"   # {days30}/{days90} are replaced by dates
+
+[demand]
+# Open issues asking for an MCP server; ranked by reactions.
+queries = ["mcp server in:title is:issue is:open"]
+min_reactions = 3
+top = 20
+
+[gaps]
+# A demand's subject is its issue title minus these words.
+stopwords = ["mcp", "server", "add", "support", "request", "feature", "for", "a", "an", "the", "new", "please"]

mcp_demand_radar-0.1.0/src/mcp_radar/__init__.py

@@ -0,0 +1,3 @@
+"""mcp-radar: GitHub demand and supply tracking for MCP servers."""
+
+__version__ = "0.1.0"

mcp_demand_radar-0.1.0/src/mcp_radar/analysis.py

@@ -0,0 +1,83 @@
+"""scan / demand / gaps logic, independent of the CLI."""
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+from .config import expand_query
+from .github import GitHub
+
+
+def scan(gh: GitHub, cfg: dict) -> dict:
+    top = cfg["radar"]["top"]
+    out = {}
+    for cat in cfg["categories"]:
+        total, repos = gh.search_repos(expand_query(cat["query"]), top)
+        out[cat["id"]] = {"label": cat["label"], "query": cat["query"], "total": total, "repos": repos}
+    return out
+
+
+def demand(gh: GitHub, cfg: dict) -> list[dict]:
+    d = cfg["demand"]
+    seen, items = set(), []
+    for q in d["queries"]:
+        for it in gh.search_issues(expand_query(q), d["top"]):
+            if it["url"] in seen or it["reactions"] < d["min_reactions"]:
+                continue
+            seen.add(it["url"])
+            items.append(it)
+    items.sort(key=lambda x: (-x["reactions"], -x["comments"]))
+    return items[: d["top"]]
+
+
+def subject_of(title: str, stopwords: list[str]) -> str:
+    words = re.findall(r"[\w.+-]+", title.lower())
+    stop = {w.lower() for w in stopwords}
+    return " ".join(w for w in words if w not in stop).strip()
+
+
+def gaps(gh: GitHub, cfg: dict, demands: list[dict]) -> list[dict]:
+    """For each demand, count existing MCP servers on the same subject.
+
+    gap_score = reactions x 1 / (1 + existing servers that are 'serious',
+    i.e. at least 10 stars). No existing server -> score equals reactions.
+    """
+    stop = cfg["gaps"]["stopwords"]
+    rows = []
+    for d in demands:
+        subject = subject_of(d["title"], stop)
+        if not subject:
+            continue
+        total, repos = gh.search_repos(f"{subject} mcp in:name,description", 10)
+        serious = [r for r in repos if r["stars"] >= 10]
+        rows.append({
+            "subject": subject, "reactions": d["reactions"], "issue": d["url"],
+            "existing": total, "serious": len(serious),
+            "best_stars": max((r["stars"] for r in repos), default=0),
+            "gap_score": round(d["reactions"] / (1 + len(serious)), 2),
+        })
+    rows.sort(key=lambda r: -r["gap_score"])
+    return rows
+
+
+# ---------- snapshots ----------
+def save_snapshot(data_dir: Path, today: str, payload: dict) -> Path:
+    data_dir.mkdir(parents=True, exist_ok=True)
+    p = data_dir / f"snapshot_{today}.json"
+    p.write_text(json.dumps({"date": today, **payload}, ensure_ascii=False, indent=1), encoding="utf-8")
+    return p
+
+
+def load_previous(data_dir: Path, today: str) -> dict | None:
+    snaps = sorted(s for s in data_dir.glob("snapshot_*.json") if s.stem != f"snapshot_{today}")
+    return json.loads(snaps[-1].read_text(encoding="utf-8")) if snaps else None
+
+
+def star_gains(current: dict, previous: dict | None) -> dict[str, int]:
+    if not previous:
+        return {}
+    old = {r["repo"]: r["stars"] for c in previous.get("scan", {}).values() for r in c["repos"]}
+    return {r["repo"]: r["stars"] - old[r["repo"]]
+            for c in current.values() for r in c["repos"] if r["repo"] in old}
+

mcp_demand_radar-0.1.0/src/mcp_radar/cli.py

@@ -0,0 +1,94 @@
+"""Command line: mcp-radar scan | demand | gaps | report."""
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import json
+import sys
+from pathlib import Path
+
+from . import __version__
+from .analysis import (demand, gaps, load_previous, save_snapshot, scan, star_gains)
+from .config import load_config
+from .demo import demo_transport
+from .github import GitHub, http_transport
+from .report import render_html, write_csv
+
+
+def _print_table(rows: list[list], headers: list[str]) -> None:
+    widths = [max(len(str(x)) for x in col) for col in zip(headers, *rows)] if rows else [len(h) for h in headers]
+    for r in [headers, *rows]:
+        print("  ".join(str(c).ljust(w) for c, w in zip(r, widths)).rstrip())
+
+
+def build_parser() -> argparse.ArgumentParser:
+    ap = argparse.ArgumentParser(prog="mcp-radar", description="GitHub demand radar for MCP servers.")
+    ap.add_argument("--version", action="version", version=__version__)
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument("--config", help="path to radar.toml (default: ./radar.toml if present)")
+    common.add_argument("--demo", action="store_true", help="use fictional offline data (no network, no token)")
+    common.add_argument("--json", action="store_true", help="print JSON instead of a table")
+    sub = ap.add_subparsers(dest="command", required=True)
+    sub.add_parser("scan", parents=[common], help="popular repositories per category")
+    sub.add_parser("demand", parents=[common], help="issues asking for an MCP, ranked by reactions")
+    sub.add_parser("gaps", parents=[common], help="demand x missing supply score")
+    rp = sub.add_parser("report", parents=[common], help="HTML + CSV report with progression")
+    rp.add_argument("--out", default="radar-out", help="output directory (default: radar-out)")
+    return ap
+
+
+def main(argv: list[str] | None = None, transport=None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        cfg = load_config(args.config)
+    except (FileNotFoundError, ValueError) as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 2
+    transport = transport or (demo_transport if args.demo else http_transport)
+    gh = GitHub(transport, pause=0 if args.demo or transport is not http_transport else 2)
+    today = dt.date.today().isoformat()
+    try:
+        if args.command == "scan":
+            res = scan(gh, cfg)
+            if args.json:
+                print(json.dumps(res, indent=1))
+            else:
+                for c in res.values():
+                    print(f"\n{c['label']} ({c['total']} repositories)")
+                    _print_table([[r["repo"], r["stars"], r["language"]] for r in c["repos"]],
+                                 ["repo", "stars", "language"])
+        elif args.command == "demand":
+            res = demand(gh, cfg)
+            if args.json:
+                print(json.dumps(res, indent=1))
+            else:
+                _print_table([[d["reactions"], d["title"], d["url"]] for d in res], ["reactions", "request", "url"])
+        elif args.command == "gaps":
+            res = gaps(gh, cfg, demand(gh, cfg))
+            if args.json:
+                print(json.dumps(res, indent=1))
+            else:
+                _print_table([[g["gap_score"], g["subject"], g["reactions"], g["serious"]] for g in res],
+                             ["score", "subject", "reactions", "existing>=10*"])
+        else:
+            data_dir = Path(cfg["radar"]["data_dir"])
+            out = Path(args.out)
+            out.mkdir(parents=True, exist_ok=True)
+            sc = scan(gh, cfg)
+            dm = demand(gh, cfg)
+            gp = gaps(gh, cfg, dm)
+            prev = load_previous(data_dir, today)
+            gains = star_gains(sc, prev)
+            save_snapshot(data_dir, today, {"scan": sc, "demand": dm, "gaps": gp})
+            (out / "report.html").write_text(
+                render_html(today, sc, dm, gp, gains, prev["date"] if prev else None), encoding="utf-8")
+            write_csv(out / "report.csv", sc, gains)
+            print(f"Report written to {out / 'report.html'} and {out / 'report.csv'}")
+    except Exception as e:  # network / API errors
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mcp_demand_radar-0.1.0/src/mcp_radar/config.py

@@ -0,0 +1,49 @@
+"""Configuration loading (radar.toml) with neutral defaults."""
+from __future__ import annotations
+
+import datetime as dt
+import tomllib
+from pathlib import Path
+
+DEFAULT_CATEGORIES = [
+    {"id": "mcp_top", "label": "Most starred MCP servers", "query": "topic:mcp-server"},
+    {"id": "mcp_new", "label": "New MCP servers (last 90 days)",
+     "query": "mcp server in:name,description created:>{days90}"},
+]
+DEFAULT_STOPWORDS = ["mcp", "server", "add", "support", "request", "feature", "for",
+                     "a", "an", "the", "new", "please", "model", "context", "protocol"]
+
+
+def default_config() -> dict:
+    return {
+        "radar": {"data_dir": "radar-data", "top": 20},
+        "categories": [dict(c) for c in DEFAULT_CATEGORIES],
+        "demand": {"queries": ["mcp server in:title is:issue is:open"],
+                   "min_reactions": 1, "top": 20},
+        "gaps": {"stopwords": list(DEFAULT_STOPWORDS)},
+    }
+
+
+def load_config(path: str | Path | None = None) -> dict:
+    """Load `path`, or ./radar.toml if present, else defaults."""
+    cfg = default_config()
+    if path is None:
+        candidate = Path("radar.toml")
+        path = candidate if candidate.exists() else None
+    if path is None:
+        return cfg
+    p = Path(path)
+    if not p.exists():
+        raise FileNotFoundError(f"Config file not found: {p}")
+    user = tomllib.loads(p.read_text(encoding="utf-8"))
+    for section in ("radar", "demand", "gaps"):
+        cfg[section].update(user.get(section, {}))
+    if user.get("categories"):
+        cfg["categories"] = user["categories"]
+    return cfg
+
+
+def expand_query(query: str, today: dt.date | None = None) -> str:
+    today = today or dt.date.today()
+    return (query.replace("{days30}", (today - dt.timedelta(days=30)).isoformat())
+                 .replace("{days90}", (today - dt.timedelta(days=90)).isoformat()))

mcp_demand_radar-0.1.0/src/mcp_radar/demo.py

@@ -0,0 +1,32 @@
+"""Offline demo transport: fictional repositories and issues, no network."""
+from __future__ import annotations
+
+import urllib.parse
+
+_REPOS = [
+    {"full_name": "acme/demo-mcp", "html_url": "https://example.invalid/acme/demo-mcp",
+     "description": "Fictional demo server", "stargazers_count": 1200, "forks_count": 80,
+     "language": "Python", "topics": ["mcp-server"], "created_at": "2026-01-10T00:00:00Z",
+     "pushed_at": "2026-11-01T00:00:00Z"},
+    {"full_name": "acme/sample-mcp", "html_url": "https://example.invalid/acme/sample-mcp",
+     "description": "Another fictional server", "stargazers_count": 40, "forks_count": 3,
+     "language": "TypeScript", "topics": ["mcp-server"], "created_at": "2026-09-01T00:00:00Z",
+     "pushed_at": "2026-11-05T00:00:00Z"},
+]
+_ISSUES = [
+    {"title": "Add Foodtracker MCP server", "reactions": {"total_count": 14}, "comments": 5},
+    {"title": "Request: Widgetbase MCP", "reactions": {"total_count": 9}, "comments": 2},
+    {"title": "Add Demo MCP server", "reactions": {"total_count": 4}, "comments": 1},
+]
+
+
+def demo_transport(url: str) -> dict:
+    parsed = urllib.parse.urlparse(url)
+    q = urllib.parse.parse_qs(parsed.query).get("q", [""])[0].lower()
+    if parsed.path.endswith("search/issues"):
+        return {"items": [{
+            "repository_url": "https://api.github.com/repos/example/registry",
+            "html_url": f"https://example.invalid/issues/{n}", "created_at": "2026-10-01T00:00:00Z", **i}
+            for n, i in enumerate(_ISSUES, 1)]}
+    items = [r for r in _REPOS if "demo" in q or "sample" in q] if " mcp in:" in q else list(_REPOS)
+    return {"total_count": len(items), "items": items}

mcp_demand_radar-0.1.0/src/mcp_radar/github.py

@@ -0,0 +1,68 @@
+"""Minimal GitHub Search client. The transport is injectable so tests and
+demo mode never touch the network."""
+from __future__ import annotations
+
+import json
+import os
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Callable
+
+Transport = Callable[[str], dict]
+
+
+def http_transport(url: str) -> dict:
+    headers = {"User-Agent": "mcp-radar", "Accept": "application/vnd.github+json"}
+    token = os.environ.get("GITHUB_TOKEN")
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    for attempt in range(3):
+        try:
+            req = urllib.request.Request(url, headers=headers)
+            with urllib.request.urlopen(req, timeout=30) as r:
+                return json.load(r)
+        except urllib.error.HTTPError as e:
+            if e.code in (403, 429) and attempt < 2:
+                time.sleep(10 if token else 60)
+                continue
+            raise
+    raise RuntimeError("unreachable")
+
+
+class GitHub:
+    def __init__(self, transport: Transport = http_transport, pause: float = 0.0):
+        self.transport = transport
+        self.pause = pause
+
+    def _get(self, path: str, params: dict) -> dict:
+        data = self.transport("https://api.github.com/" + path + "?" + urllib.parse.urlencode(params))
+        if self.pause:
+            time.sleep(self.pause)
+        return data
+
+    def search_repos(self, query: str, top: int = 20) -> tuple[int, list[dict]]:
+        data = self._get("search/repositories",
+                         {"q": query, "sort": "stars", "order": "desc", "per_page": min(top, 100)})
+        repos = [{
+            "repo": r["full_name"], "url": r["html_url"],
+            "description": (r.get("description") or "").strip(),
+            "stars": r.get("stargazers_count", 0), "forks": r.get("forks_count", 0),
+            "language": r.get("language") or "", "topics": r.get("topics", []),
+            "created": (r.get("created_at") or "")[:10], "updated": (r.get("pushed_at") or "")[:10],
+        } for r in data.get("items", [])]
+        return data.get("total_count", 0), repos
+
+    def search_issues(self, query: str, top: int = 20) -> list[dict]:
+        data = self._get("search/issues",
+                         {"q": query, "sort": "reactions", "order": "desc", "per_page": min(top, 100)})
+        out = []
+        for i in data.get("items", []):
+            repo = i.get("repository_url", "").removeprefix("https://api.github.com/repos/")
+            out.append({
+                "repo": repo, "title": i.get("title", ""), "url": i.get("html_url", ""),
+                "reactions": (i.get("reactions") or {}).get("total_count", 0),
+                "comments": i.get("comments", 0), "created": (i.get("created_at") or "")[:10],
+            })
+        return out

mcp_demand_radar-0.1.0/src/mcp_radar/report.py

@@ -0,0 +1,55 @@
+"""HTML + CSV report rendering."""
+from __future__ import annotations
+
+import csv
+import html
+from pathlib import Path
+
+CSS = ("body{font:15px/1.5 system-ui,sans-serif;max-width:960px;margin:2rem auto;padding:0 1rem;"
+       "color:#1d2433}table{border-collapse:collapse;width:100%;margin:.5rem 0 2rem}"
+       "th,td{border-bottom:1px solid #dde1e8;padding:.35rem .5rem;text-align:left}"
+       "td.n{text-align:right;font-variant-numeric:tabular-nums}small{display:block;color:#5b6478}"
+       "@media(prefers-color-scheme:dark){body{background:#12161e;color:#e6e9ef}"
+       "a{color:#3cc4bb}th,td{border-color:#2a3140}}")
+
+
+def _e(s) -> str:
+    return html.escape(str(s))
+
+
+def render_html(date: str, scan: dict, demands: list[dict], gap_rows: list[dict],
+                gains: dict[str, int], prev_date: str | None) -> str:
+    parts = [f"<h1>MCP radar – {_e(date)}</h1>"]
+    parts.append(f"<p>Gains since {_e(prev_date)}.</p>" if prev_date
+                 else "<p>First snapshot: run again next week to see star gains.</p>")
+    for cid, c in scan.items():
+        rows = "".join(
+            f'<tr><td><a href="{_e(r["url"])}">{_e(r["repo"])}</a><small>{_e(r["description"][:140])}</small></td>'
+            f'<td class="n">{r["stars"]}</td>'
+            f'<td class="n">{("+%d" % gains[r["repo"]]) if r["repo"] in gains else "–"}</td></tr>'
+            for r in c["repos"])
+        parts.append(f"<h2>{_e(c['label'])}</h2><p>{c['total']} matching repositories.</p>"
+                     f"<table><tr><th>Repository</th><th>Stars</th><th>Gain</th></tr>{rows}</table>")
+    if demands:
+        rows = "".join(f'<tr><td><a href="{_e(d["url"])}">{_e(d["title"])}</a><small>{_e(d["repo"])}</small></td>'
+                       f'<td class="n">{d["reactions"]}</td></tr>' for d in demands)
+        parts.append(f"<h2>Demand</h2><table><tr><th>Request</th><th>Reactions</th></tr>{rows}</table>")
+    if gap_rows:
+        rows = "".join(f'<tr><td><a href="{_e(g["issue"])}">{_e(g["subject"])}</a></td>'
+                       f'<td class="n">{g["reactions"]}</td><td class="n">{g["serious"]}</td>'
+                       f'<td class="n">{g["gap_score"]}</td></tr>' for g in gap_rows)
+        parts.append("<h2>Gaps</h2><table><tr><th>Subject</th><th>Demand</th><th>Existing (≥10★)</th>"
+                     f"<th>Score</th></tr>{rows}</table>")
+    return (f'<!doctype html><html lang="en"><head><meta charset="utf-8">'
+            f'<meta name="viewport" content="width=device-width,initial-scale=1">'
+            f"<title>MCP radar {_e(date)}</title><style>{CSS}</style></head><body>{''.join(parts)}</body></html>")
+
+
+def write_csv(path: Path, scan: dict, gains: dict[str, int]) -> None:
+    with open(path, "w", newline="", encoding="utf-8-sig") as f:
+        w = csv.writer(f, delimiter=";")
+        w.writerow(["category", "repo", "stars", "gain", "forks", "language", "created", "url"])
+        for cid, c in scan.items():
+            for r in c["repos"]:
+                w.writerow([cid, r["repo"], r["stars"], gains.get(r["repo"], ""), r["forks"],
+                            r["language"], r["created"], r["url"]])

mcp_demand_radar-0.1.0/tests/test_radar.py

@@ -0,0 +1,103 @@
+import json
+import urllib.parse
+
+import pytest
+
+from mcp_radar import analysis, cli
+from mcp_radar.config import default_config, expand_query, load_config
+from mcp_radar.github import GitHub
+
+
+def fake_transport(calls=None, stars=100):
+    def t(url):
+        if calls is not None:
+            calls.append(url)
+        p = urllib.parse.urlparse(url)
+        q = urllib.parse.parse_qs(p.query)["q"][0]
+        if p.path.endswith("search/issues"):
+            return {"items": [
+                {"title": "Add Foo MCP server", "html_url": "u/1", "comments": 2,
+                 "repository_url": "https://api.github.com/repos/o/r", "reactions": {"total_count": 10}},
+                {"title": "Add Bar MCP", "html_url": "u/2", "comments": 0,
+                 "repository_url": "https://api.github.com/repos/o/r", "reactions": {"total_count": 6}},
+                {"title": "Low", "html_url": "u/3", "comments": 0,
+                 "repository_url": "https://api.github.com/repos/o/r", "reactions": {"total_count": 0}},
+            ]}
+        items = [{"full_name": "a/b", "html_url": "u", "stargazers_count": stars, "forks_count": 1,
+                  "created_at": "2026-01-01T00:00:00Z", "pushed_at": "2026-02-01T00:00:00Z"}]
+        if q.startswith("foo"):
+            items = [{"full_name": "x/foo-mcp", "html_url": "u", "stargazers_count": 50,
+                      "created_at": "2026-01-01T00:00:00Z", "pushed_at": "2026-02-01T00:00:00Z"}]
+        if q.startswith("bar"):
+            return {"total_count": 0, "items": []}
+        return {"total_count": len(items), "items": items}
+    return t
+
+
+def test_expand_query_dates():
+    import datetime as dt
+    assert expand_query("x>{days30}", dt.date(2026, 11, 13)) == "x>2026-10-14"
+
+
+def test_config_defaults_and_file(tmp_path):
+    f = tmp_path / "c.toml"
+    f.write_text('[radar]\ntop=5\n[[categories]]\nid="x"\nlabel="X"\nquery="topic:x"\n')
+    cfg = load_config(f)
+    assert cfg["radar"]["top"] == 5 and cfg["categories"][0]["id"] == "x"
+    with pytest.raises(FileNotFoundError):
+        load_config(tmp_path / "missing.toml")
+
+
+def test_scan_demand_gaps():
+    gh = GitHub(fake_transport())
+    cfg = default_config()
+    sc = analysis.scan(gh, cfg)
+    assert set(sc) == {"mcp_top", "mcp_new"}
+    dm = analysis.demand(gh, cfg)
+    assert [d["reactions"] for d in dm] == [10, 6]  # zero-reaction issue filtered
+    gp = analysis.gaps(gh, cfg, dm)
+    assert gp[0]["subject"] == "bar" and gp[0]["gap_score"] == 6.0  # nobody serves Bar
+    assert gp[1]["subject"] == "foo" and gp[1]["gap_score"] == 5.0  # one serious server halves it
+
+
+def test_subject_of():
+    assert analysis.subject_of("Add Amazon Connect MCP server", ["add", "mcp", "server"]) == "amazon connect"
+
+
+def test_star_gains(tmp_path):
+    cur = {"c": {"repos": [{"repo": "a/b", "stars": 120}, {"repo": "n/w", "stars": 5}]}}
+    analysis.save_snapshot(tmp_path, "2026-11-06", {"scan": {"c": {"repos": [{"repo": "a/b", "stars": 100}]}}})
+    prev = analysis.load_previous(tmp_path, "2026-11-13")
+    assert analysis.star_gains(cur, prev) == {"a/b": 20}
+    assert analysis.load_previous(tmp_path, "2026-11-06") is None
+
+
+def test_cli_report_with_progression(tmp_path, monkeypatch, capsys):
+    monkeypatch.chdir(tmp_path)
+    (tmp_path / "radar-data").mkdir()
+    (tmp_path / "radar-data" / "snapshot_2020-01-01.json").write_text(json.dumps(
+        {"date": "2020-01-01", "scan": {"mcp_top": {"repos": [{"repo": "a/b", "stars": 60}]}}}))
+    assert cli.main(["report", "--out", "o"], transport=fake_transport()) == 0
+    html = (tmp_path / "o" / "report.html").read_text()
+    assert "Gains since 2020-01-01" in html and "+40" in html
+    assert "a/b" in (tmp_path / "o" / "report.csv").read_text()
+
+
+def test_cli_demo_works_offline(tmp_path, monkeypatch, capsys):
+    monkeypatch.chdir(tmp_path)
+    for cmd in ("scan", "demand", "gaps"):
+        assert cli.main([cmd, "--demo"]) == 0
+    out = capsys.readouterr().out
+    assert "acme/demo-mcp" in out and "foodtracker" in out
+    assert cli.main(["gaps", "--demo", "--json"]) == 0
+    assert cli.main(["report", "--demo", "--out", "o"]) == 0
+    assert (tmp_path / "o" / "report.html").exists()
+
+
+def test_cli_errors(tmp_path, monkeypatch, capsys):
+    monkeypatch.chdir(tmp_path)
+    assert cli.main(["scan", "--config", "nope.toml"]) == 2
+
+    def boom(url):
+        raise RuntimeError("rate limited")
+    assert cli.main(["scan"], transport=boom) == 1