ARBOR

Arbor Docs

Everything you need to understand, install, and get the most from Arbor.

Quick Start

Get your first blast-radius report in under a minute. No configuration files, no YAML, no CLI setup.

1
Install the GitHub App
Click the button below and select which repositories to analyze. Arbor only requests read access to your code and write access to post PR comments.
2
Open a pull request
Within 30 seconds of a PR being opened (or a new commit pushed), Arbor analyzes the changed files and posts a blast-radius report as a PR comment.
3
Read your report
The comment shows which files have the highest impact, which callers are affected, and what actions to take before merging.
Install Arbor on GitHub — Free

How It Works

Arbor uses static analysis — not an LLM — to build a provably accurate dependency graph and compute the exact blast radius of any code change.

⎇
PR opened
GitHub webhook
⎘
Shallow clone
head SHA only
⟨/⟩
AST parse
Tree-sitter
◈
Graph build
petgraph
⊕
BFS traversal
blast radius
✎
PR comment
+ status check

1. Webhook trigger

When a pull request is opened or a new commit is pushed, GitHub sends a webhook to Arbor. The webhook is verified with HMAC-SHA256 and a 202 is returned immediately — analysis happens asynchronously so GitHub never times out.

2. Shallow clone

Arbor clones only the HEAD commit of the PR branch into an ephemeral workspace. This keeps clone times under 5 seconds even for large repos. The clone is deleted after analysis completes.

3. AST parsing with Tree-sitter

Every source file is parsed with Tree-sitter to produce a concrete syntax tree. Tree-sitter supports incremental parsing and runs in milliseconds per file. Arbor extracts: function definitions, class declarations, import statements, function call sites, and type references.

4. Dependency graph construction

Parsed symbols are wired into a directed graph (powered by petgraph in Rust) where each node is a code symbol and each edge is a "calls" or "imports" relationship. Arbor resolves cross-file imports to connect edges across the whole codebase — not just within single files.

5. BFS blast-radius traversal

For each changed file, Arbor identifies which symbols were modified. It then runs a breadth-first search upward through the graph — finding every function that calls the changed symbols, then every function that calls those callers, up to the configured depth. The result is the precise set of affected nodes.

6. Centrality scoring

Each node gets a centrality score based on how many other nodes depend on it (similar to PageRank). High-centrality nodes are flagged explicitly — they're the ones where a small change has outsized systemic impact.

How centrality is computed
// Simplified: centrality = incoming_edges / total_edges_in_graph
// High centrality (>0.7) → flagged as high-risk node
// Combined with direct caller count to produce per-file risk level:

if centrality > 0.7 || direct_callers >= 5 || total_affected >= 20 {
    RiskLevel::High
} else if centrality > 0.4 || direct_callers >= 2 {
    RiskLevel::Medium
} else {
    RiskLevel::Low
}

Language Support

Arbor uses Tree-sitter grammars, which means language support is broad and adding new languages is straightforward. All languages share the same graph engine and analysis logic.

TS
TypeScript
.ts
JS
JavaScript
.js
RS
Rust
.rs
PY
Python
.py
GO
Go
.go
JV
Java
.java
C
C
.c
C++
C++
.cpp
C#
C#
.cs
DA
Dart
.dart
KT
Kotlin
.kt
SW
Swift
.swift
RB
Ruby
.rb
PHP
PHP
.php
What's analyzed per language
  • ✓Function and method definitions + call sites
  • ✓Class and interface declarations
  • ✓Import / require / use statements (cross-file edges)
  • ✓Type references and generic instantiations
  • ✓Module exports and re-exports

Reading Your Report

Every PR gets a structured comment posted by the Arbor bot. Here's exactly what each section means.

A
arbor-cloudbot commented
🔴 Arbor — Blast Radius Report
PR #94 · feat/payments → main · Risk Score: 87%
> 3 files changed · 6 symbols · 14 upstream callers
### Impact by File
| Risk | File | Direct | Transitive |
| 🔴 HIGH | **src/payments.rs** | 8 | 14 |
| 🟡 MED | src/api.rs | 2 | 5 |
### ⚠️ High-Centrality Nodes
- **`process_payment`** centrality 89% · 8 callers
Core function — affects all checkout flows
### ✅ Before You Merge
- Trace 14 affected callers before merging
- Write tests for `process_payment` (89% centrality)
- Request senior engineer review
A
Overall risk emoji + score 0–100%
B
Summary stats — files, symbols, callers
C
Per-file risk table, sorted HIGH → LOW
D
High-centrality node callouts with centrality %
E
Recommended actions before merging
A
Risk Score
0–100% normalized score combining the fraction of the graph affected and the peak centrality seen. Above 70% = High, 30–70% = Medium, below 30% = Low.
B
Summary stats
Quick counts of files changed, symbols modified, upstream callers (things that call your code), and downstream dependencies (things your code calls).
C
Impact by File table
Each changed file gets a row with its risk level, how many symbols changed, direct callers (1 hop), and transitive callers (all hops). Sorted HIGH → MEDIUM → LOW.
D
High-Centrality Nodes
Symbols with centrality above 60% are called out explicitly. These are the most dangerous nodes to change — a small mistake cascades broadly.
E
Before You Merge
Specific, context-aware recommended actions generated from the blast radius data. Tells you exactly what to verify, test, or do differently before merging.

Commit Status Gates

Arbor posts a GitHub commit status on every PR — the green/red check in your PR's status area. This puts blast radius in the critical path of every merge decision.

🟢 Passing
Low / no blast radius
🟡 Neutral
Medium blast radius
🔴 Failing
High blast radius
⏳ Pending
Analysis in progress

Branch protection rules can require the Arbor status to pass before merging. Go to your repository settings → Branches → Branch protection rules → "Require status checks to pass before merging" → search for arbor/blast-radius.

Dashboard

The Arbor dashboard (available on Team and Enterprise plans) gives you a persistent view of blast radius trends across all your repos.

Analyses
Every PR analysis is stored for 90 days. Browse by repo, filter by risk level, and drill into individual reports with the full blast-radius breakdown.
Dependency graph
Interactive graph visualization of your codebase's dependency structure. Click any node to see its callers, callees, and centrality score.
Trends
Track how your codebase's blast-radius profile changes over time. Are high-centrality nodes increasing? Is the average risk going up or down?
Insights
Automated insights about hotspot files — the 5% of files that appear in 80% of high-risk analyses. These are your highest-leverage refactoring targets.
Open dashboard →

FAQ

Does Arbor work on private repositories?+
Private repositories are supported on the Team and Enterprise plans. The Free plan analyzes only public repositories.
How long does analysis take?+
Typically 15–45 seconds for most repositories. Large monorepos (100k+ files) can take 60–90 seconds. The analysis runs asynchronously so GitHub's webhook timeout is never hit.
Does Arbor store my source code?+
No. Arbor clones the repository into a temporary workspace, runs the analysis, then deletes the clone. We store only the dependency graph (node names, file paths, edge relationships) and the analysis result — not raw source.
Can I configure what Arbor flags as 'high risk'?+
The risk thresholds (centrality > 0.6 for high-risk node callout, 5+ direct callers for HIGH risk) are currently fixed. Per-repo configuration is on the roadmap.
What happens when Arbor can't parse a file?+
Unparseable files are skipped and noted in the confidence section of the report. The analysis continues with the remaining files. Low confidence reports include suggestions for improving graph coverage.
Does Arbor analyze test files?+
Test files are included in the graph as nodes but are weighted differently. Changes to test files don't inflate blast radius — only changes to non-test code trigger the analysis.