README.md

May 14, 2026 · View on GitHub

RepoRadar

RepoRadar in one minute

RepoRadar helps you do the most meaningful, most impactful research on GitHub — fast.

Developers find new repos across GitHub Trending, Hacker News, launch posts, X/Twitter, and README skimming. Even after spotting a promising one, the next hour evaporates into cloning, installing, and reading examples just to find out whether the repo actually does what you need. Discovery and evaluation are two slow steps stacked on top of each other, and neither lets you express what you actually want — what trade-off between maturity and momentum, how much you weight production-readiness versus shipping velocity, whether you'd rather adopt a battle-tested library or bet on a rising star.

What RepoRadar does

It collapses both halves of that workflow into one surface:

Land on a default ranking of trending repos.
Drill into a topic — click a tag chip (Agents · RAG · LLM Apps · Rust · Security) or type your own. The ranking re-runs against that topic with a multi-tier topic → keyword → all-time fallback, so weird queries like "a podcast platform" still surface something.
Set up to three priorities in the SORT BY bar — e.g. Trending Momentum → Production Readiness → Documentation Quality. The top-right card is now exactly the repo you should look at first.
Refine with the widgets on the left — drag a slider, pull a vertex on the decagon hex, or ask the CopilotKit chat agent to nudge things for you. Every input binds to the same internal taste vector, and the card grid on the right re-ranks and re-renders live. That live reshape is the generative-UI bit: nothing is pre-baked.
Click Deploy on any repo. RepoRadar spins up a working micro-app for that specific repo on Cloudflare Workers, at its own <slug>.reporadar.io URL — backed by a per-deploy D1 database so Save buttons, Lists, and Counters work for real. You don't just read about the repo; you kick the tires.

A concrete example: building a Hermes-style agent

Say you want to build a Hermes-style agent. You'd start by adopting Hermes itself through its highest-starred repo — the canonical implementation everyone else is building on. Then you want to layer in skills, tools, memory, evals. Drill into the agents topic, set your priorities (Production Readiness → Documentation Quality → Ease of Prototyping), and the next-most-popular repos line up in the order that matches your taste. Tap Deploy on two or three of them and you have working interactive demos to compare side by side. Days of evaluation collapse into minutes.

Judge path

Open reporadar.io.
Click a tag like Agents or type a topic into the search box.
Click 1–3 chips on the SORT BY bar to set priority order.
Drag a slider, pull a hex vertex, or ask the CopilotKit chat to re-rank — watch the cards re-order live.
Click Deploy on a repo card.
Open the generated <slug>.reporadar.io app and use its Save, List, or Counter controls. Those persist through D1, so the deploy is a real app, not a static mock.

Why this isn't a chatbot

The hackathon's bar: would this have been impossible with a chat interface? For RepoRadar, yes — twice over.

The home surface is a multi-modal taste editor, not a conversation. Five inputs — tag chips, search, the SORT BY priority bar, ten sliders, and a draggable decagon hex — all bind to the same taste vector and reshape the card grid at 60fps. A chat dock is there too, and CopilotKit's useCopilotAction flows through the same vector, but the chat is one input among five, not the entire interface. You can drag the hex with one hand and watch the ranking change without typing a word.
The deploy artifact is a working app with its own database, not a description of one. Click Deploy and Gemini emits an A2UI JSON document describing a playground / dashboard / control-panel / wizard / widget-grid / reader. Our renderer mounts it at <slug>.reporadar.io from R2. Per-slug D1 tables (records + counters) make Submit buttons, Lists, and Counters real — not props. Type into a field, hit Save, the data persists.

A chatbot can describe a repo. RepoRadar lets you use it.

Tracks targeted

Kill the Dashboard — the radar is composed per query, ranked per slider, never pre-built
No Designer, No Problem (moonshot) — every deployed surface's frontend is agent-emitted A2UI JSON. No designer touched any of them

How we used each sponsor's tech

The hackathon shipped four protocols, each with a sponsor behind it. We used all four and credit each here.

Sponsor	Protocol / Product	Role in RepoRadar
Google DeepMind	A2UI	The output schema for every deployed surface. Gemini 2.5 Flash emits A2UI JSON; our vanilla-JS renderer maps the subset (Layout, Container, Heading, Text, Button, TextField, CheckBox, Slider, List, Tabs, ProgressBar, Counter, Image, Code) to live DOM. We extended the schema with interactive primitives — `action="submit"` collects sibling fields and POSTs to `/api/records`; `source="records"` auto-loads a List from D1; `Counter` is a new node type backed by `/api/counters/:name`. Gemini also powers the in-app non-English description translation so foreign-language READMEs surface in English on the cards.
CopilotKit	AG-UI + CopilotKit	Both protocols ship together here. Top-level React framework: `<CopilotKit>` provider, `<CopilotPopup>` chat dock, `useCopilotAction`, `useCopilotReadable`, and the `GoogleGenerativeAIAdapter` driving the agentic loop. Every `useCopilotAction("rankRepos")` and `useCopilotAction("deployRepo")` call — plus the `renderAndWaitForResponse` deploy form — flows through AG-UI events between the Next.js client and our CopilotRuntime.
Manufact	MCP Apps (via mcp-use)	`workers/mcp/` exposes `rank_repos` and `deploy_variant` as a Model Context Protocol server built on mcp-use. Live remote at `https://reporadar-mcp.let-s-go-christo.workers.dev/mcp` (Streamable HTTP / SSE), plus a local stdio entry (`workers/mcp/src/stdio.ts`) for Claude Desktop. The same rank-and-deploy flow runs inside Claude Desktop / ChatGPT MCP / any MCP client. See `workers/mcp/README.md`.
LangChain	LangChain	Roadmap item. The next milestone uses LangChain for deeper multi-source repo research (Hacker News + Product Hunt + launch-post signals fused with GitHub) and long-term taste memory across sessions. Not in the four-hour build; planned for v0.x→1.0.

Architecture

┌──────────────────────────────────────────────────────────────────────────┐
│  reporadar.io  —  Next.js 16 + React 19 + Tailwind 4 + TypeScript       │
│  Deployed via @opennextjs/cloudflare → Cloudflare Worker                 │
│  ┌──────────────────────────────────────────────────────────────────┐  │
│  │ <CopilotKit> Provider                                            │  │
│  │   ├── Header + LIVE indicator + version + last-updated + refresh │  │
│  │   ├── Tags row (5 chips + inline white search bar)               │  │
│  │   ├── PriorityBar (10 dim chips, click-order = sort priority)    │  │
│  │   ├── Time-window selector (30d / 90d / 1y / all)                │  │
│  │   ├── Sidebar:                                                   │  │
│  │   │     • InteractiveRadar  (custom-SVG decagon, drag handles)   │  │
│  │   │     • 3 + 7 sliders (with caret expand)                      │  │
│  │   ├── Card grid (rank pills, score gradient, Deploy CTA,         │  │
│  │   │              infinite scroll, click-to-snap weights)         │  │
│  │   ├── <CopilotPopup>  (default-collapsed chat dock)              │  │
│  │   ├── useCopilotAction("rankRepos")  → handler → /api/repos      │  │
│  │   └── useCopilotAction("deployRepo") → renderAndWaitForResponse  │  │
│  └──────────────────────────────────────────────────────────────────┘  │
│           │                                       │                      │
│           │ AG-UI events                          │ POST /api/deploy     │
│           ▼                                       ▼                      │
│  /api/copilotkit/route.ts                /api/deploy/route.ts            │
│    CopilotRuntime + GoogleGenerativeAI     1. fetchRepo (Octokit)        │
│    Adapter (model: gemini-2.5-flash)       2. Gemini → A2UI surface JSON │
│                                            3. forward to deploy worker   │
│                                            4. Resend email notify (opt)  │
└──────────────────────────────────────────────────────────────────────────┘
                                                    │
                              forward + persist     │
                                                    ▼
┌──────────────────────────────────────────────────────────────────────────┐
│  reporadar-deploy  (Cloudflare Worker)                                   │
│    POST /deploy     → fetch repo ctx, call Gemini REST, validate,        │
│                        write surface JSON to R2, upsert deploys row in D1│
│    POST /persist    → just persist + return URL (used by Next.js path)   │
└──────────────────────────────────────────────────────────────────────────┘
                                                    │
                                                    ▼
┌──────────────────────────────────────────────────────────────────────────┐
│  reporadar-serve  (Cloudflare Worker, route: *.reporadar.io/*)          │
│    GET  /                  → HTML shell + bootstraps the renderer        │
│    GET  /surface.json      → R2 stream of <slug>/surface.json            │
│    GET  /_renderer.js      → vanilla-JS A2UI renderer                    │
│    GET  /api/records[?type=X]                                           │
│    POST /api/records       → write per-slug record to D1                 │
│    DELETE /api/records/:id → slug-scoped delete                          │
│    GET/POST /api/counters/:name → per-slug counter upsert                │
└──────────────────────────────────────────────────────────────────────────┘
                                                    │
                                                    ▼
┌──────────────────────────────────────────────────────────────────────────┐
│  reporadar-mcp  (Cloudflare Worker, MCP server)                          │
│    /mcp  (Streamable HTTP / SSE) → rank_repos, deploy_variant            │
│    workers/mcp/src/stdio.ts      → local stdio entry for Claude Desktop  │
└──────────────────────────────────────────────────────────────────────────┘

The 10 dimensions

Every repo is scored 0–100 on each axis (heuristic, derived from GitHub data). Higher = better on every axis. The radar, sliders, sort bar, and chat all share the same 10:

Trending Momentum — stars × younger-age (rate-of-attention proxy)
Shipping Velocity — recent commits, falls back to "pushed this week"
Project Maturity — forks + age + stable-topic bonus
Community Engagement — stars + forks + issue cadence
Activity Recency — days since last push (capped at 30d)
Ease of Prototyping — starter / boilerplate / example / template signals + recent activity + clear quickstart
Production Readiness — tests, CI, docs, security policy present
Security & Trust — explicit security tooling + active maintenance + low open-vuln pressure
Documentation Quality — README length log-normalized + examples + docs site
Ecosystem Pull — downstream pull / adoption / dependents (stars proxy today; real impl would use npm/pypi)

See app/lib/types.ts for DIMENSION_META (label + short label + tooltip help) and app/lib/scoring.ts:computeDimensions for the math.

End-to-end flow

User lands at reporadar.io. Radar is pre-loaded with trending agent repos (no chat needed to see results).
User clicks a tag, types a query, drags a slider, drags a hex vertex, or types in the chat — any one of those re-ranks the cards in real time.
User clicks Deploy on a card. Modal opens with the repo description + an optional hint field + an optional email/phone for completion notify.
POST /api/deploy → Gemini decides form factor + emits A2UI JSON → forwarded to reporadar-deploy worker → R2 + D1 persisted.
New tab opens at <slug>.reporadar.io. The serve worker streams the A2UI JSON and the renderer mounts it.
The user can use the deployed app. Form fields persist on Submit. Lists update. Counters increment. Records can be deleted. Per-slug isolation in D1.
(Optional) Resend fires an email when configured: subject "<repo> → <formFactor> live at <url>".

What's new since the hackathon ship

Shipped after the four-hour build, all live on reporadar.io:

Infinite scroll with visible loading state + retry affordance
Time-window selector — 30d / 90d / 1y / all — re-fetches against GitHub with the chosen since: cutoff
Card-click → weight snap — clicking a repo card snaps sliders + hex to that repo's 10-dim fingerprint; subsequent drags still re-rank in real time
Real-time re-rank on drag — sliders, hex vertices, and chat-driven weight changes reorder cards live (not on submit)
Non-English description translation — Gemini translates foreign READMEs so the cards stay scannable
Deploy completion email signup — optional email/phone field in the deploy modal; Resend fires on completion
Background deploys — the deploy runs in the background so you can keep exploring while a slug builds
"How to test" panel — the deploy success state explains what each generated surface actually does
Hackathon tag chips + hero star badge + production smoke test suite

What we would build next

RepoRadar should become a faster way to decide whether software is worth trying.

One-click trials: deploy or run generated repo-specific apps quickly so users can test a project without losing time to setup, dependency issues, or long install docs.
User reviews: add ratings, notes, saved comparisons, and follow-up reviews from people who actually tried the repo.
Broader discovery signals: combine GitHub with Product Hunt, Hacker News, Twitter/X, app directories, changelogs, launch posts, and trend reports.
Generated repo reports: explain what the repo does, who it is for, setup difficulty, maturity, risks, alternatives, and whether it is worth testing.
More generated surfaces: add guided setup flows, API explorers, benchmark runners, onboarding wizards, and repo-specific test harnesses.
Sandboxed execution: connect generated interfaces to safe ephemeral environments so users can run examples and inspect outputs before touching their own machine.

Stack

Next.js 16 (App Router) + React 19 + Tailwind 4 + TypeScript
CopilotKit 1.57 — @copilotkit/react-core, @copilotkit/react-ui, @copilotkit/runtime
Gemini 2.5 Flash via @google/generative-ai (Next.js side) and Gemini REST (Workers side)
Octokit for GitHub
Recharts sub-charts (PolarGrid for spokes); the main hex is a custom SVG with pointer-event drag handles
Cloudflare:
- Workers — reporadar (Next.js apex via @opennextjs/cloudflare), reporadar-deploy, reporadar-serve, reporadar-mcp
- D1 — deploys registry, per-slug records, per-slug counters, OpenNext incremental cache
- R2 — reporadar-surfaces (A2UI JSON per deploy)
- Custom Domain — reporadar.io apex + *.reporadar.io wildcard, Universal SSL, Always-Use-HTTPS, HSTS (1y, includeSubDomains), TLS 1.2 minimum
Resend — email-on-deploy-complete (configured per worker via wrangler secret put RESEND_API_KEY)
mcp-use — MCP server framework powering the remote + stdio MCP transports

Local development

# 1. Install
npm install

# 2. Add your Gemini API key
cp .env.local.example .env.local
# edit .env.local and fill in GOOGLE_API_KEY (and optionally GITHUB_TOKEN, RESEND_API_KEY)

# 3. Run
npm run dev
# → http://localhost:3000

`.env.local`

GOOGLE_API_KEY=AIza...                    # required for chat + deploy generation
GEMINI_MODEL=gemini-2.5-flash             # optional override
GITHUB_TOKEN=ghp_...                      # optional; raises the GitHub anon rate limit
DEPLOY_WORKER_URL=https://reporadar-deploy.<account>.workers.dev   # optional forward target
NEXT_PUBLIC_DEPLOY_WORKER_URL=...         # mirrors DEPLOY_WORKER_URL for client features
RESEND_API_KEY=re_...                     # optional; enables real email notify
RESEND_FROM="RepoRadar <onboarding@resend.dev>"  # optional override

Deploying

One-time setup (already done for the hackathon account)

export CLOUDFLARE_ACCOUNT_ID=<your-account-id>

# D1 + R2
wrangler d1 create reporadar
wrangler d1 execute reporadar --remote --file=workers/deploy/migrations/0001_init.sql
wrangler d1 execute reporadar --remote --file=workers/deploy/migrations/0002_records.sql
wrangler r2 bucket create reporadar-surfaces
wrangler r2 bucket create reporadar-opennext-cache  # used by OpenNext

# Secrets per worker
echo "<your-key>" | wrangler secret put GOOGLE_API_KEY --config workers/deploy/wrangler.toml
echo "<your-key>" | wrangler secret put GOOGLE_API_KEY  # for the apex Next.js worker
# optional:
echo "<your-key>" | wrangler secret put RESEND_API_KEY
echo "<your-key>" | wrangler secret put RESEND_API_KEY --config workers/deploy/wrangler.toml

Per-deploy

# Apex Next.js app at reporadar.io
npx opennextjs-cloudflare build
wrangler deploy

# Deploy worker (Gemini → A2UI → R2/D1)
wrangler deploy --config workers/deploy/wrangler.toml

# Serve worker (*.reporadar.io interactive renderer + API)
wrangler deploy --config workers/serve/wrangler.toml

# MCP worker (rank_repos + deploy_variant over Streamable HTTP / SSE)
wrangler deploy --config workers/mcp/wrangler.toml

DNS / TLS hardening (already applied via API)

PATCH /zones/:id/settings/always_use_https            { value: "on" }
PATCH /zones/:id/settings/automatic_https_rewrites    { value: "on" }
PATCH /zones/:id/settings/security_header             { strict_transport_security }
PATCH /zones/:id/settings/min_tls_version             { value: "1.2" }
POST  /zones/:id/dns_records  { type: "AAAA", name: "*", content: "100::", proxied: true }

Repo layout

app/
  api/
    copilotkit/route.ts     # CopilotRuntime + GoogleGenerativeAIAdapter
    deploy/route.ts         # Gemini → A2UI surface, forward to worker, Resend notify
    repos/route.ts          # Octokit fetch with multi-tier topic+keyword fallback + translate
  components/
    Providers.tsx           # <CopilotKit> wrapper
    RepoRadarApp.tsx        # the home surface — tags row, sort bar, time-window, sliders, hex, cards
    PriorityBar.tsx         # 10-chip sort priority bar
    InteractiveRadar.tsx    # custom-SVG decagon with draggable vertices
    RepoCard.tsx            # rank pill + score gradient + Deploy CTA
    DeployForm.tsx          # in-modal + in-chat deploy flow with progress + milestones
    A2UIRenderer.tsx        # /d/[slug] React A2UI renderer (local dev mirror)
  lib/
    types.ts                # Repo, ScoredRepo, Dimension, DIMENSION_META, etc.
    scoring.ts              # rankRepos + computeDimensions (10 PRD axes)
    github.ts               # Octokit fetch with multi-tier fallback
    translate.ts            # Gemini-driven non-English description translation
    a2ui-types.ts           # A2UI subset typings
  d/[slug]/page.tsx         # local /d/<slug> route mirror of the live serve worker
workers/
  deploy/
    src/index.ts            # POST /deploy, POST /persist; Gemini REST + R2/D1 + Resend
    migrations/0001_init.sql
    migrations/0002_records.sql
  serve/
    src/index.ts            # *.reporadar.io router + renderer + REST backend
  mcp/
    src/worker.ts           # Cloudflare Worker entry — mcp-use HTTP/SSE MCP server
    src/stdio.ts            # local stdio entry for Claude Desktop (official MCP SDK)
    src/tools.ts            # rank_repos + deploy_variant impls (shared by both transports)
wrangler.jsonc              # apex Next.js worker config
open-next.config.ts         # OpenNext for Cloudflare adapter config

Submission

Repo: this one
Live: reporadar.io
Demo video: see top of repo (Loom)
Protocols used: A2UI (Google DeepMind) · AG-UI + CopilotKit (CopilotKit) · MCP Apps (Manufact / mcp-use)
Sponsors honored: AI Tinkerers · Google DeepMind · CopilotKit · Manufact · LangChain
Tracks: Kill the Dashboard · No Designer No Problem (moonshot)
Team: Christo Roberts · Craig · Priyanshu (AI Tinkerers SF)
Hackathon: Generative UI Global Hackathon · AI Tinkerers SF · May 9, 2026

License

MIT.