code-review-graph

Parses source code using Tree-sitter AST parsing across 40+ languages, extracting structural entities (functions, classes, types, imports) and storing them in a persistent knowledge graph. Tracks file changes via SHA-256 hashing to enable incremental updates—only re-parsing modified files rather than rescanning the entire codebase on each invocation. The parser system maintains a directed graph of code entities and their relationships (CALLS, IMPORTS_FROM, INHERITS, CONTAINS, TESTED_BY, DEPENDS_ON) without requiring full re-indexing.

When a file changes, the system traces the directed graph to identify all potentially affected code entities—callers, dependents, inheritors, and tests. This 'blast radius' computation uses graph traversal algorithms (BFS/DFS) to walk the CALLS, IMPORTS_FROM, INHERITS, DEPENDS_ON, and TESTED_BY edges, producing a minimal set of files and functions that Claude must review. The system excludes irrelevant files from context, reducing token consumption by 6.8x to 49x depending on repository structure and change scope.

Includes an automated evaluation framework (`code-review-graph eval --all`) that benchmarks the tool against real open-source repositories, measuring token reduction, impact analysis accuracy, and query performance. The framework compares naive full-file context inclusion against graph-optimized context, reporting metrics like average token reduction (8.2x across tested repos, up to 49x on monorepos), precision/recall of blast radius analysis, and query latency. Results are aggregated and visualized in benchmark reports, enabling teams to understand the expected token savings for their codebase.

Persists the knowledge graph to a local SQLite database, enabling the graph to survive across sessions and be queried without re-parsing the entire codebase. The storage layer maintains tables for nodes (entities), edges (relationships), and metadata, with indexes optimized for common query patterns (entity lookup, relationship traversal, impact analysis). The SQLite backend is lightweight, requires no external services, and supports concurrent read access, making it suitable for local development workflows and CI/CD integration.

Exposes the knowledge graph as an MCP (Model Context Protocol) server that Claude Code and other LLM assistants can query via standardized tool calls. The MCP server implements a set of tools (graph management, query, impact analysis, review context, semantic search, utility, and advanced analysis tools) that allow Claude to request only the relevant code context for a task instead of re-reading entire files. Integration is bidirectional: Claude sends queries (e.g., 'what functions call this one?'), and the MCP server returns structured graph results that fit within token budgets.

Generates embeddings for code entities (functions, classes, documentation) and stores them in a vector index, enabling semantic search queries like 'find functions that handle authentication' or 'locate all database connection logic'. The system uses embedding models (likely OpenAI or similar) to convert code and natural language queries into vector space, then performs similarity search to retrieve relevant code entities without requiring exact keyword matches. Results are ranked by semantic relevance and integrated into the MCP tool suite for Claude to query.

Monitors the filesystem for code changes (via file watchers or git hooks) and automatically triggers incremental graph updates without manual intervention. When files are modified, the system detects changes via SHA-256 hashing, re-parses only affected files, and updates the knowledge graph in real-time. Auto-update hooks integrate with git workflows (pre-commit, post-commit) to keep the graph synchronized with the working directory, ensuring Claude always has current structural information.

Generates concise, token-optimized summaries of code changes and their context by combining blast radius analysis with semantic search. Instead of sending entire files to Claude, the system produces structured summaries that include: changed code snippets, affected functions/classes, test coverage, and related code patterns. The summaries are designed to fit within Claude's context window while providing sufficient information for accurate code review, achieving 6.8x to 49x token reduction compared to naive full-file inclusion.

Provides a VS Code extension that visualizes the knowledge graph as an interactive diagram, allowing developers to explore code structure, dependencies, and impact analysis results directly in the editor. The extension displays nodes (files, functions, classes) and edges (relationships) in a visual format, supports filtering and search, and integrates with VS Code's code navigation (go-to-definition, find-references). Developers can click on entities to view details, trace dependencies, and understand code structure without leaving the editor.

Supports parsing and indexing code in 40+ programming languages (Python, JavaScript, TypeScript, Go, Rust, Java, C++, etc.) using language-specific Tree-sitter grammars, while maintaining a unified, language-agnostic graph schema. All languages are represented with the same node types (File, Class, Function, Type, Test) and edge types (CALLS, IMPORTS_FROM, INHERITS, CONTAINS, TESTED_BY, DEPENDS_ON), enabling cross-language dependency analysis in monorepos. The parser system automatically detects language based on file extension and applies the appropriate grammar.

Implements an incremental update mechanism that computes the delta between the current codebase state and the previous indexed state, then applies only the necessary graph updates. The system uses SHA-256 file hashing to detect changes, identifies which entities (functions, classes, imports) were added, modified, or deleted, and updates only the affected graph nodes and edges. This delta-based approach reduces update time from O(n) to O(delta), where delta is the number of changed entities, enabling fast graph synchronization even in large codebases.

Provides a comprehensive command-line interface for building, querying, and analyzing the knowledge graph. Commands include: `build` (initial graph construction), `update` (incremental updates), `query` (graph traversal and entity lookup), `impact` (blast radius analysis), `review` (code review context generation), `watch` (continuous synchronization), `visualize` (graph export for visualization), and `eval` (evaluation and benchmarking). The CLI is designed for both interactive use and integration into CI/CD pipelines, with structured output formats (JSON, YAML) for programmatic consumption.