Gasetta

Live at gasetta.com

A live, AI-summarised feed of the neo-project GitHub org — consensus chips, founder markers, and the state of every active thread, refreshed every few hours.

Gasetta reads the Neo blockchain's GitHub organisation every four hours and turns the raw firehose — issues, pull requests, discussions, releases, commits — into a scannable feed of summaries. Each card carries:

• a one-line AI summary of what the thread is about and where it stands
• a consensus chip (Resolved · Decided · Leaning approve · Open · Split · Stalled)
• a sentiment indicator (calm · mixed · contentious)
• a founder marker when one of Neo's two founders weighed in
• a version chip (N3 / N4) when the thread is protocol-tagged

The point: a Neo follower opens the site, scans the feed in 30 seconds, and knows what's being argued about, what shipped, and where the founders stand — without ever opening GitHub.

flowchart LR
gh["GitHub<br/>neo-project org"]
ingest["ingest function<br/>(every 4h)"]
db[("Postgres<br/>(Supabase)")]
summarize["summarize function<br/>(every 4h)"]
openai["OpenAI<br/>gpt-4o-mini"]
spa["React SPA<br/>ranked card feed"]
gh -- "REST + GraphQL" --> ingest
ingest --> db
db -- "pending rows" --> summarize
summarize -- "thread + comments" --> openai
openai -- "summary · chip · sentiment · quotes" --> summarize
summarize --> db
db -- "PostgREST + RLS" --> spa

Loading

---

What you get

A vertical feed of cards, filterable by type (issues / PRs / discussions / releases / founder-touched), version (N3 / N4 / all), and repo. Sort by Hot (importance), New, or Most discussed.

flowchart TB
subgraph App["App shell"]
direction LR
left["Left rail<br/>type · version · repo · stats · legend"]
feed["Center feed<br/>ranked cards · 1 per row"]
right["Right rail<br/>about · N4 momentum · top contributors · resolved"]
end
topbar["TopBar · wordmark · nav · updated Xm ago"]
topbar --> App

Loading

Each card opens to a thread page with the full consensus block: a multi-sentence summary, the consensus chip, key points, decisions reached in the thread, and a pulled-out founder quote when applicable.

---

Architecture in one diagram

flowchart TD
cron1["pg_cron · every 4h on the hour"]
cron2["pg_cron · every 4h · :10"]
ingest["ingest function<br/>GitHub → Postgres"]
summarize["summarize function<br/>per-item summaries"]
raw[("raw rows<br/>issues · PRs · discussions · releases<br/>+ comments · reviews")]
llm[("LLM output on the same rows<br/>+ llm_calls cost telemetry")]
spa["React SPA"]
cron1 --> ingest --> raw
cron2 --> summarize
raw -- "pending rows" --> summarize
summarize --> llm
raw --> spa
llm --> spa

Loading

Two Edge Functions, one Postgres database, one static SPA. Full detail in ARCHITECTURE.md.

---

Tech stack

• Database — Supabase Postgres
• Compute — Supabase Edge Functions (Deno/TypeScript)
• Scheduling — pg_cron + pg_net
• LLM — OpenAI (gpt-4o-mini for per-item summaries; gpt-4o for the optional org-level digest)
• Frontend — Vite + React + TypeScript + React Router + TanStack Query, shipped as a static SPA

---

Local development

Prerequisites

• Node 20+ and npm
• Supabase CLI
• Docker (for the local Supabase stack)
• A GitHub fine-grained PAT with read-only scopes: metadata:read · contents:read · pull requests:read · issues:read · discussions:read
• An OpenAI API key

1. Bring up the local Supabase stack

cd supabase
supabase start

This starts Postgres, PostgREST, Kong, and the Edge Function runtime in Docker. First run takes a couple of minutes; subsequent runs are fast.

2. Apply migrations + seed

supabase db reset

This applies 0001_schema.sql, 0002_rls.sql, 0003_summary_gate.sql, 0004_cron.sql, and then runs seed.sql (which seeds the two founders).

3. Configure secrets for the Edge Functions

cp supabase/.env.example supabase/.env.local
# Edit supabase/.env.local and fill in:# GITHUB_TOKEN=<your fine-grained PAT># OPENAI_API_KEY=<your OpenAI key>

4. Run the functions

supabase functions serve --env-file supabase/.env.local

In another terminal, kick off an initial ingest + summarize:

curl -sS -X POST http://127.0.0.1:54321/functions/v1/ingest
# … wait for it to finish (10-30 min on a 30-day bootstrap window) …
curl -sS -X POST http://127.0.0.1:54321/functions/v1/summarize

The cron schedules in 0004_cron.sql will keep the pipeline ticking from that point on. To make them fire against the locally-served functions you'll need to set the gasetta.config table (see ARCHITECTURE.md §1).

5. Run the frontend

cd apps/web
cp .env.example .env.local
# Fill in VITE_SUPABASE_URL and VITE_SUPABASE_ANON_KEY# (from `supabase status -o env`)
npm install
npm run dev

Open the URL Vite prints. You'll see the live feed populated from your local database.

---

Deploying

Supabase

supabase link --project-ref YOUR_PROJECT_REF
supabase db push # apply migrations to the cloud DB
supabase functions deploy ingest summarize
supabase secrets set --env-file supabase/.env.production

Then configure the cron table on the cloud DB:

insert intogasetta.config (key, value) values
('functions_base_url', 'https://YOUR_PROJECT.supabase.co/functions/v1'),
('service_role_key', '<dashboard service-role key>')
on conflict (key) do updateset value =excluded.value;

Frontend

The frontend is a static SPA. Build it and deploy the apps/web/dist/ directory to any static host (Vercel, Netlify, Cloudflare Pages, GitHub Pages, etc.):

cd apps/web
npm run build

Set VITE_SUPABASE_URL and VITE_SUPABASE_ANON_KEY in the host's environment variable settings.

---

Repo layout

gasetta/
├─ ARCHITECTURE.md system design + data model
├─ README.md you are here
├─ LICENSE
├─ CONTRIBUTING.md
├─ supabase/
│ ├─ config.toml
│ ├─ seed.sql
│ ├─ migrations/ SQL migrations
│ └─ functions/ Deno Edge Functions
│ ├─ _shared/ GitHub client, OpenAI client, DB helpers, prompts
│ ├─ ingest/ stage 1: GitHub → Postgres
│ └─ summarize/ stage 2: Postgres → OpenAI → Postgres
└─ apps/
└─ web/ Vite + React + TypeScript SPA
└─ src/
├─ components/ atoms · FeedCard · LeftRail · RightRail · TopBar
├─ pages/ Feed · Thread · Repos · Repo · Founders · Versions · Archive · About
└─ lib/ supabase client · v3Loader · v3Context

---

Contributing

See CONTRIBUTING.md.

Short version: open an issue first for non-trivial changes; commits follow Conventional Commits; no --no-verify.

---

License

MIT.

---

gasetta.com · github.com/smartargs/gasetta · issues · MIT

_{Built by the community.}