AetherMap - Visual Blast-Radius Reviewer

A GitLab flow that fires on a merge request → Orbit blast-radius+dependency+ownership queries →auto-posts back to the MR: (a) an interactive "impact map", (b) a risk summary+auto-suggested reviewers.

Comment

Inspiration

A diff shows you what changed — never what those lines were holding up. The merge requests that break production are usually the small, innocent-looking ones sitting under half the codebase. GitLab Orbit already indexes the whole codebase into a Knowledge Graph, so I wanted to put that knowledge where the decision happens: inside the merge request, as a verdict and a picture.

What it does

When a merge request opens, AetherMap:

  • Traces the blast radius — it walks Orbit's call graph backwards (CALLS / EXTENDS) from the changed lines to find everything the change can break.
  • Scores the risk (LOW → CRITICAL), names the fragile cores (widely-called symbols), and flags the untested blast zone (impacted code with no test).
  • Acts — it posts the review as a merge-request note with the impact map embedded, and applies an aethermap::<tier> label.
  • Renders an interactive impact map — and can even play the blast radius as sound.

On GitLab's own codebase (over a million graph relationships indexed in about two minutes), the blast radius of the can? permission check is CRITICAL: more than 2,250 definitions affected, almost none with a test in the radius.

How I built it

  • Every number comes from Orbit through its official orbit sql interface — one recursive query over the graph does the core work, so the same code runs locally and in CI.
  • Zero runtime dependencies — even the PNG embedded in the MR comment is encoded in pure Python.
  • It ships three ways: a one-line CI include:, an Agent Skill, and a published AI Catalog agent that queries the graph live and comments on merge requests.
  • A remote adapter taps Orbit's SDLC graph (reviewers, vulnerabilities) via the official query DSL, schema-validated against the live schema.

I tested it honestly

I replayed 36 real Django commits (18 that were later reverted + 18 random ones). Blast radius does not predict reverts (61% vs 72% high-risk) — but it proved that the median ordinary commit silently reaches 39 downstream definitions nobody can see in a diff. So AetherMap is about visibility, not prophecy.

Challenges I ran into

Orbit's node IDs are 64-bit and overflow JavaScript's safe integers (had to remap them for the map); getting the remote query envelope right against a live, evolving API; and making one code path behave identically across local Windows and Linux CI (encodings, long paths).

Accomplishments I'm proud of

A full blast-radius review on real codebases in seconds, a genuinely beautiful dependency-free impact map (with sonification), and an honest back-test instead of a cherry-picked number.

What I learned

How much reviewing power is latent in a point-in-time SDLC graph once you can traverse it — and that the real problem isn't risky changes sneaking past review; it's that all changes are reviewed blind.

What's next

Live reviewers and vulnerability overlays from Orbit's remote graph once the namespace finishes indexing, cross-project blast radius, and inline per-symbol annotations in the diff.

Built With

  • duckdb
  • gitlab-duo-agent-platform
  • gitlab-knowledge-graph
  • gitlab-orbit
  • gitlabci/cd
  • glab
  • html5
  • python
  • sql
  • web-audio-api
Share this project:

Updates