https://github.com/Anandb71/arbor
Graph-native code intelligence that replaces embedding-based RAG with deterministic program understanding.
https://github.com/Anandb71/arbor
ai-tools ast code-analysis code-analysis-tool developer-tools flutter graph mcp model-context-protocol rust static-analysis tree-sitter visualization
Last synced: 10 days ago
JSON representation
Graph-native code intelligence that replaces embedding-based RAG with deterministic program understanding.
- Host: GitHub
- URL: https://github.com/Anandb71/arbor
- Owner: Anandb71
- License: mit
- Created: 2026-01-04T13:11:55.000Z (about 2 months ago)
- Default Branch: main
- Last Pushed: 2026-02-01T17:19:29.000Z (18 days ago)
- Last Synced: 2026-02-02T01:30:23.130Z (18 days ago)
- Topics: ai-tools, ast, code-analysis, code-analysis-tool, developer-tools, flutter, graph, mcp, model-context-protocol, rust, static-analysis, tree-sitter, visualization
- Language: Rust
- Homepage: https://www.github.com/anandb71/arbor
- Size: 38.5 MB
- Stars: 79
- Watchers: 1
- Forks: 14
- Open Issues: 2
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- Contributing: CONTRIBUTING.md
- License: LICENSE
- Code of conduct: CODE_OF_CONDUCT.md
- Security: SECURITY.md
- Roadmap: docs/ROADMAP.md
Awesome Lists containing this project
README
# Arbor v1.5.0
**Graph‑Native Intelligence for Codebases**
> Know what breaks *before* you break it.
## What's New in v1.5
- **Accurate Token Counting** — tiktoken (cl100k_base) replaces heuristic estimates for precise LLM context budgets
- **Fuzzy Symbol Suggestions** — Typo tolerance with Jaro-Winkler matching: `arbor refactor autth` → "Did you mean: `auth`?"
- **Enhanced MCP/AI Integration** — Rich JSON output with confidence, roles, and edge explanations for Claude/Cursor
- **GUI Version Watermark** — "Arbor v1.5" badge for brand visibility in screenshots
- **Better Python UX** — Empty `__init__.py` handled silently (no false warnings)
## Overview
---
## What is Arbor?
Arbor is a **local‑first impact analysis engine** for large codebases. Instead of treating code as text, Arbor parses your project into a **semantic dependency graph**. This lets you trace *real execution paths*—callers, callees, imports, inheritance, and cross‑file relationships—so you can confidently understand the consequences of change.
Unlike keyword search or vector‑based RAG systems, Arbor answers questions like:
> *“If I change this function, what actually breaks?”*
with **structural certainty**, not probabilistic guesses.
---
## Example: Blast Radius Detection
Before refactoring `detect_language`, inspect its true impact:
```bash
$ arbor refactor detect_language
Analyzing detect_language...
Confidence: High | Role: Core Logic
• 15 callers, 3 dependencies
• Well-connected with manageable impact
> 18 nodes affected (4 direct, 14 transitive)
Immediate Impact:
• parse_file (function)
• get_parser (function)
Recommendation: Proceed with caution. Verify affected callers.
```
This is **execution‑aware analysis**, not text matching.
---
## Graphical Interface
Arbor v1.4 ships with a **native GUI** for interactive impact analysis.
```bash
arbor gui
```
### GUI Capabilities
* **Symbol Search** – Instantly locate functions, classes, and methods
* **Impact Visualization** – Explore direct and transitive dependencies
* **Privacy‑Safe** – File paths are hidden by default for clean screenshots
* **Export** – Copy results as Markdown for PRs and design docs
> The CLI and GUI share the *same* analysis engine—no feature gaps.
---
## Quick Start
1. **Install Arbor** (CLI + GUI):
```bash
cargo install arbor-graph-cli
```
2. **Run Impact Analysis**:
```bash
cd your-project
arbor refactor
```
3. **Launch the GUI**:
```bash
arbor gui
```
📘 See the [Quickstart Guide](docs/QUICKSTART.md) for advanced workflows.
---
## Why Arbor?
Most AI coding tools treat code as **unstructured text**, relying on vector similarity. This approach is fast—but imprecise.
**Arbor builds a graph.**
Every function, class, and module is a node. Every call, import, and reference is an edge. When you ask a question, Arbor follows the graph—*the same way your program executes*.
```text
Traditional RAG: Arbor Graph Analysis:
"auth" → 47 results AuthController
(keyword similarity) ├── calls → TokenMiddleware
├── queries → UserRepository
└── emits → AuthEvent
```
The result: **deterministic, explainable answers**.
---
## Core Features
### Native GUI
A lightweight, high‑performance interface bundled directly with Arbor—no browser, no server.
### Confidence Scoring
Each result includes an **explainable confidence level**:
* **High** – Fully resolved, statically verifiable paths
* **Medium** – Partial uncertainty (e.g., polymorphism)
* **Low** – Heuristic or dynamic resolution
### Node Classification
Arbor infers architectural roles automatically:
* **Entry Point** – APIs, CLIs, main functions
* **Core Logic** – Domain and business rules
* **Utility** – Widely reused helpers
* **Adapter** – Interfaces, boundaries, and bridges
### AI Bridge (MCP)
Arbor implements the **Model Context Protocol (MCP)**, enabling LLMs (e.g., Claude) to query the graph directly:
* `find_path(start, end)` – Trace logic flow
* `analyze_impact(node)` – Compute blast radius
* `get_context(node)` – Retrieve semantically related code
### Cross‑File Resolution
A global symbol table resolves:
* Imports and re‑exports
* Inheritance and interfaces
* Overloads and namespaces
`User` in `auth.ts` is never confused with `User` in `types.ts`.
---
## Supported Languages
| Language | Status | Parser Coverage |
| -------------- | ------ | ----------------------------------------- |
| **Rust** | ✅ | Functions, Structs, Traits, Impls, Macros |
| **TypeScript** | ✅ | Classes, Interfaces, Types, Imports, JSX |
| **JavaScript** | ✅ | Functions, Classes, Vars, Imports |
| **Python** | ✅ | Classes, Functions, Imports, Decorators |
| **Go** | ✅ | Structs, Interfaces, Funcs, Methods |
| **Java** | ✅ | Classes, Interfaces, Methods, Fields |
| **C** | ✅ | Structs, Functions, Enums, Typedefs |
| **C++** | ✅ | Classes, Namespaces, Templates |
| **C#** | ✅ | Classes, Methods, Properties, Interfaces |
| **Dart** | ✅ | Classes, Mixins, Widgets |
> **Python note:** Decorators, `__init__.py`, and `@dataclass` are statically analyzed. Dynamic dispatch is flagged with reduced confidence.
---
## Build from Source
```bash
git clone https://github.com/Anandb71/arbor.git
cd arbor/crates
cargo build --release
```
### Linux GUI Dependencies
```bash
sudo apt-get install -y pkg-config libx11-dev libxcb-shape0-dev libxcb-xfixes0-dev \
libxkbcommon-dev libgtk-3-dev libfontconfig1-dev libasound2-dev libssl-dev cmake
```
---
## Troubleshooting
### Symbol not found?
* **.gitignore** – Arbor respects it (`arbor status --files`)
* **File type** – Ensure the extension is supported
* **Empty files** – Skipped (except `__init__.py`)
* **Dynamic calls** – `eval` / runtime reflection may not resolve
* **Case sensitivity** – Use `arbor query ` to search
### Empty graph?
Run `arbor status` to verify file detection and parser health.
---
## Security Model
Arbor is **Local‑First by design**:
* No data exfiltration
* Fully offline
* No API keys
* Fully open source
Your code never leaves your machine.
---
## License
MIT License. See [LICENSE](LICENSE) for details.