arbor

Arbor is a local-first graph-based code analysis tool that exposes an MCP (Model Context Protocol) interface. It builds a semantic dependency graph of your codebase so you can query how changes propagate through callers, callees, imports, and cross-file relationships. When used via its MCP integration, you can ask it to trace paths between two nodes, analyze the blast radius of a change, or generate a graph-backed architectural brief. Arbor provides a CLI for impact analysis (arbor refactor, arbor diff, arbor check, arbor open) and a native GUI for interactive exploration. Typical workflows involve indexing your project with arbor setup, then running analyses like arbor refactor <symbol> to see potential breakage or arbor diff/arbor check to understand risk.

Capabilities to expect:

• find_path(start, end): Trace a logic path through the graph to understand how data or control flows from one symbol to another.
• analyze_impact(node): Compute blast radius and identify callers, dependencies, and potential breaking changes.
• get_logic_path(node): Generate an architectural brief that explains how a node fits into the graph and its relations.
• Cross-file and language support: Arbor parses multiple languages (Rust, TypeScript, JavaScript, Python, Go, etc.) to build its semantic graph and supports language-specific relationships like imports, inheritance, and symbol resolution.
• MCP integration: Use the MCP endpoints to query the graph programmatically from LLMs or external tooling, enabling deterministic, explainable analysis within Codex/Claude-like workflows.

To use the MCP-enabled features, start Arbor, index your project, and then invoke the CLI MCP-capable commands or the GUI for interactive exploration. The CLI and GUI share the same engine, so there are no feature gaps between modes.

Prerequisites:

• A supported environment (macOS, Linux, or Windows with a compatible shell).
• Rust toolchain installed (recommended) or use the one-command installers provided by Arbor.

Installation options:

1. Rust toolchain method (recommended for development):

   • Install Rust and Cargo: follow https://www.rust-lang.org/tools/install
   • Install Arbor CLI via Cargo: cargo install arbor-graph-cli
   • Verify installation: arbor --version

2. One-command installers (no Rust toolchain required):

   • macOS/Linux: curl -fsSL https://raw.githubusercontent.com/Anandb71/arbor/main/scripts/install.sh | bash
   • Windows (PowerShell): irm https://raw.githubusercontent.com/Anandb71/arbor/main/scripts/install.ps1 | iex

3. After installation: index your project and start analysis

   • Navigate to your project directory: cd /path/to/your/project
   • Initialize/index the project for Arbor: arbor setup
   • Run an analysis example (CLI): arbor refactor <symbol-name> arbor diff arbor check --max-blast-radius 30 arbor open <symbol>
   • Launch the GUI (optional): arbor gui

Notes:

• The Arbor CLI and GUI share the same analysis engine. If you prefer a GUI-first workflow, install and launch arbor gui to interact with the graph visually.
• Installation instructions may pin versions or assets in the docs (docs/INSTALL.md) for reliability in production use.

Tips and caveats:

• Arbor builds a semantic graph of your codebase; ensure your project is fully indexed with arbor setup before performing impact analyses.
• For MCP usage, you can access methods like find_path(start, end), analyze_impact(node), and get_logic_path(node) to support deterministic queries from LLMs.
• If you encounter path resolution issues between similarly named symbols, rely on the graph’s classification (Entry Point, Core Logic, Utility, Adapter) to disambiguate.
• Memory and indexing time scale with project size; for very large repos, consider incremental indexing or using arbor index --changed-only after initial full index.
• Check docs/QUICKSTART.md and docs/INSTALL.md for advanced workflows, version pinning guidance, and GUI/tutorials.