Developer Tools
Graph-AwareCode Review
A bundled Plexon plugin that turns pull request review into a graph query. Persistent Tree-sitter knowledge graph of your repo, 22 MCP tools for impact analysis, and a review subagent that reads the slice a diff touches, not whole files. Roughly 8× fewer review tokens on typical codebases, so deep reviews fit in a single turn.
Review Pull Requests Without Re-Reading Whole Files
Traditional AI reviewers burn context reading every file the diff touches. The code-review-graph plugin builds a persistent Tree-sitter knowledge graph of your repository and returns only the slice of code the change actually affects: signatures, docstrings, call sites, and test references. On typical repos this cuts review token usage by roughly 8× versus reading whole files, so deep reviews fit in a single turn even inside large monorepos.
- Bundled Plexon plugin: one click to enable, no separate install, no CLI to manage
- Wraps the upstream code-review-graph MCP server (22 tools) from tirth8205/code-review-graph (MIT)
- Ships a companion skill that teaches Plexon when and how to call each graph tool
- Ships a companion subagent for structured, rubric-driven deep PR reviews
Blast-Radius Analysis for Any Change
Every changed entity gets a blast radius: the transitive set of functions, files, and end-to-end flows it can reach. You see whether a one-line edit in a utility will quietly touch every feature in the app, or whether a scary-looking refactor is actually isolated. Ask "what does this change touch?" and Plexon answers with graph-derived certainty, not string matching.
- get_impact_radius_tool: forward and reverse transitive callers for any function, class, or file
- get_affected_flows_tool: which end-to-end flows pass through the changed entity
- get_review_context_tool: token-optimised context (signatures, call sites, tests) replacing whole-file reads
- Risk scoring maps diffs to affected entities and surfaces any changed entity with zero test coverage
Incremental, Fast, and Local
The graph is built once and then maintained incrementally. After you edit a file, the next rebuild re-parses only what changed and completes in under two seconds. The graph is stored in a local SQLite file: nothing about your code, your diffs, or your commits ever leaves your machine. Plexon's zero-knowledge posture extends cleanly to the plugin: the MCP server runs as a local subprocess, not a cloud API.
- Tree-sitter parsers for 19 programming languages plus Jupyter notebooks
- Incremental rebuilds complete in under 2 seconds after edits
- Local SQLite storage: your code, your graph, your machine
- No API keys, no network calls, no telemetry
Explore Unfamiliar Codebases
Graph-aware context is not just for PR reviews. Ask for an architecture overview, list the largest or riskiest functions in the repo, find tightly-coupled clusters of code, trace end-to-end flows, or semantic-search the graph for entities related to a concept. The same tools that power reviews also power exploration: onboarding a new codebase becomes a single conversation instead of a week of grep.
- get_architecture_overview_tool: top-level module map of any repository
- list_communities_tool and get_community_tool: surfaces clusters of tightly-coupled code
- semantic_search_nodes_tool: vector search over entity descriptions (optional embeddings)
- list_large_functions_tool: complexity and size-ranked refactor candidates
- Multi-repo search via list_repos_tool and cross_repo_search_tool
Familiar Workflow, Plexon-Native
If you have used code-review-graph from Claude Code, Cursor, or Zed, the upstream slash commands map directly to Plexon's skill and subagent workflows. /code-review-graph:build-graph becomes the skill's build step. /code-review-graph:review-delta and /code-review-graph:review-pr map to the skill's and subagent's review loops. You do not memorise any commands. Just ask Plexon for the review you want in plain English, and the skill routes the request to the right sequence of graph tools.
- Upstream /code-review-graph:build-graph → "build the knowledge graph for this repo"
- Upstream /code-review-graph:review-delta → "review my uncommitted changes"
- Upstream /code-review-graph:review-pr → "review PR #142" (with the github-toolkit plugin)
- The companion subagent enforces a strict 7-step review loop for large or high-stakes diffs
Requirements and Setup
Enable the plugin from the Plugins panel and Plexon takes care of the rest: the MCP server is started automatically, the skill and subagent appear in their panels, and the first review call is ready to run. The only prerequisite is uv (which provides the uvx runner), a modern Python package manager you can install in seconds. No pip install of the package itself, no API keys, and no account to create.
- Install uv from docs.astral.sh/uv: one-line install on macOS, Linux, and Windows
- Open the Plexon Plugins panel and toggle on code-review-graph
- First call downloads the Python package via uvx (5–30 seconds on a warm network); every subsequent session is warm from the uv cache
- Point Plexon at a git repository and ask "review the last commit". No further configuration
What the plugin gives you
22 MCP Tools for Code Review
The upstream code-review-graph MCP server exposes 22 graph tools covering blast radius, affected flows, review context, architecture overviews, semantic search, community detection, and risk scoring, all available to Plexon the moment the plugin is enabled.
Persistent Knowledge Graph
A Tree-sitter-derived graph of functions, classes, files, imports, call edges, and flows. Rebuilt incrementally on file saves and git commits so the graph is never more than two seconds behind the code.
≈8× Fewer Review Tokens
Upstream benchmarks report an average 8.2× reduction in review token usage across tested repositories. The savings come from returning token-optimised review context per entity instead of reading whole files. Deep reviews that used to blow through the context window fit in a single turn.
19 Languages + Jupyter
Tree-sitter parsers cover 19 production languages plus Jupyter notebooks. Polyglot repositories get a unified graph across every file the parser understands.
Blast-Radius Analysis
Every changed entity gets a forward and reverse transitive impact list plus the set of end-to-end flows it participates in. "What does this change touch?" becomes a single tool call instead of a grep expedition.
Test-Coverage Risk Scoring
Tests are first-class nodes in the graph. Any changed entity with zero test references is automatically surfaced as a risk. No custom CI plumbing required.
Companion Review Skill
A bundled skill teaches Plexon when to call build_or_update_graph_tool, detect_changes_tool, get_impact_radius_tool, and get_review_context_tool, mapping upstream slash commands (/build-graph, /review-delta, /review-pr) to concrete tool sequences.
Deep-Review Subagent
A dedicated code-review-graph subagent enforces a strict 7-step review loop (build → detect changes → blast radius → affected flows → review context → five-axis review → structured write-up) for large or high-stakes diffs.
Semantic Search and Exploration
Ask for the entity that "validates JWTs" or "handles billing webhooks" and the plugin answers from a vector index over graph descriptions. Useful for onboarding onto unfamiliar codebases, not just reviewing diffs.
Compatible with github-toolkit
Combine with the github-toolkit plugin to review real PRs by number: github-toolkit fetches the diff and metadata, code-review-graph supplies the blast radius and review context.
Local SQLite Storage
The knowledge graph lives in a local SQLite file next to your repo. No cloud, no account, no upload. Deleting the file forces a clean rebuild on the next call.
Zero Network Calls
The MCP server is a local uvx subprocess. Your code, your diffs, and your review prompts stay on your machine, consistent with Plexon's zero-knowledge architecture.
MIT-Licensed Upstream
Powered by tirth8205/code-review-graph (MIT). Plexon bundles the upstream MCP server unchanged and ships only the companion skill, subagent, and MCP config.