Repository Intelligence Graph (RIG)

• Repository Intelligence Graph is a structured, semantically enriched graph representing code repositories and their internal and external relationships.
• Its construction uses deterministic multi-pass extraction, combining AST parsing, metadata mining, and node/edge enrichment for full project coverage.
• RIGs enable advanced query, retrieval, and agent-assisted analysis, enhancing code generation, bug localization, and build/test process efficiency.

A Repository Intelligence Graph (RIG) is a formal, structured, and semantically rich graph representation of the internal and external relationships within a software repository. RIGs are designed to serve as authoritative, queryable indices for code repositories, build systems, and artifacts, enabling advanced repository-level reasoning, retrieval, generation, and analytics by both humans and AI agents. RIGs are central constructs in state-of-the-art frameworks for software repository mining, code retrieval, agent-based code generation, build/test comprehension, and AI-assisted software engineering (Serban et al., 2020, Tao et al., 22 May 2025, Yang et al., 27 Mar 2025, Bevziuk et al., 10 Oct 2025, Shah et al., 27 Sep 2025, Cherny-Shahar et al., 15 Jan 2026, Athale et al., 20 May 2025, Ouyang et al., 2024, Wang et al., 7 Sep 2025, Chinthareddy, 13 Jan 2026).

1. Formal Definition and Core Schema

A Repository Intelligence Graph is a directed, labeled multigraph $G = (V, E, \mathcal{T}_V, \mathcal{T}_E)$ over repository artifacts, code entities, and (optionally) repository metadata and infrastructure:

• Nodes ($V$): Typed entities such as developers, commits, files, methods, classes, functions, issues, pull requests, components, aggregators, runners, test definitions, external packages, and package managers. Node schemas are extensible, often including both statically determined code-structure nodes and dynamically extracted metadata (e.g., descriptions, embeddings, code metrics) (Serban et al., 2020, Tao et al., 22 May 2025, Bevziuk et al., 10 Oct 2025, Cherny-Shahar et al., 15 Jan 2026).
• Edges ($E$ and $\mathcal{T}_E$): Typed, possibly weighted relations such as containment, authorship, update, imports, calls, inheritance, build/test dependencies, issue references, and semantic/architectural connections. Edge weights are optionally assigned for path-based scoring or shortest-path queries (Yang et al., 27 Mar 2025). Cross-level edges explicitly relate artifacts across levels (e.g., issues to code, tests to components).
• Node and Edge Attribute Functions ($L_V, L_E$, feature vectors, embeddings): Each node and edge carries type labels, semantic or architectural attributes, and often vector representations (LLM/code embeddings) and/or metadata pointers (source span, evidence locations, etc.) (Tao et al., 22 May 2025, Bevziuk et al., 10 Oct 2025).
• Graph Persistence: RIGs are usually materialized in an ACID-compliant graph database (e.g., Neo4j) or in-memory graph structures suitable for fast subgraph retrieval, expansion, and traversal.
• Example Node/Edge Types Table:

Node Types	Edge Types	Notes
File, Class, Method	defines_class	File → Class
Function, Attribute	has_method	Class → Method
Developer, Commit	author_of	Developer → Commit
Component, Test	depends_on	Build artifacts, coverage, explicit deps
Issue, PullRequest	refersTo, mentions	Issue artifact → code or PR
PackageManager, ExtPkg	managed_by, uses	Build/test infra, dependency management

This schema supports comprehensive representation of both codebase topology and the evolving artifact structure of a repository.

2. Construction Algorithms and Deterministic Extraction

RIG construction proceeds by deterministic, multi-pass extraction from repository sources:

• Source Extraction: ASTs are parsed for each file using language-appropriate parsers or frameworks (e.g., Tree-sitter for Python/Java/C++) to extract classes, methods, functions, imports, inheritance, containment hierarchies, and references. Specialized extractors target specific layers (e.g., SPADE for build systems, CMake File API for build/test artifacts, PyDriller for commit metadata) (Serban et al., 2020, Cherny-Shahar et al., 15 Jan 2026, Chinthareddy, 13 Jan 2026).
• Artifact and Metadata Mining: External artifacts (issues, PRs, build/test configs, package manifests, etc.) are parsed via regular expressions, API queries, or direct file traversal to identify links to code entities and dependencies (Yang et al., 27 Mar 2025, Cherny-Shahar et al., 15 Jan 2026).
• Node/Edge Enrichment: Entity nodes are augmented with LLM-generated summaries, doc-strings, metrics (e.g., cyclomatic complexity), and vector embeddings via pretrained code models (e.g., CodeT5+, BAAI/bge-large-en-v1.5, deepseek-coder-1.3B-instruct) (Tao et al., 22 May 2025, Bevziuk et al., 10 Oct 2025, Shah et al., 27 Sep 2025).
• Edge Expansion and Cross-File Resolution: Edges for cross-file references, external dependencies, hierarchical relations, and consumer–provider interfaces are consolidated after initial per-file parsing (Shah et al., 27 Sep 2025, Chinthareddy, 13 Jan 2026).
• Incremental Updates: In CI/CD scenarios, only changed or new entities are parsed and merged; the graph supports efficient incremental updating without full re-extraction (Yang et al., 27 Mar 2025, Cherny-Shahar et al., 15 Jan 2026).

Extraction is explicitly deterministic for architectures such as SPADE (for build/test, with evidence tracking), and for AST-based approaches, ensuring reproducibility and full project coverage (Cherny-Shahar et al., 15 Jan 2026, Chinthareddy, 13 Jan 2026).

3. Retrieval, Query, and Expansion Mechanisms

RIGs underpin semantically precise, multi-hop, and structurally aware retrieval pipelines for code understanding, code generation, repair, and agent autonomy:

• Hybrid Retrieval: User queries are handled by a combination of token/embedding search (semantic similarity), graph expansion (n-hop traversal from retrieved seeds), and structural matching (e.g., call, containment, type, dependency) (Athale et al., 20 May 2025, Bevziuk et al., 10 Oct 2025, Wang et al., 7 Sep 2025, Shah et al., 27 Sep 2025).
• Ranking and Scoring: Subgraph or node scoring blends semantic embedding similarity ($\mathrm{cosine}(q, x_v)$), structural proximity (graph distance, path-mining), and adaptive composition (neural or MMR-based rerankers), with explicit path tracing for interpretability and localization (Yang et al., 27 Mar 2025, Wang et al., 7 Sep 2025).
• Agent-Oriented Query: LLM-based agents or assistants map NL queries to deterministic graph queries (e.g., Cypher for Neo4j), or employ RL/search mechanisms (e.g., MCTS in RANGER) for graph exploration (Shah et al., 27 Sep 2025, Bevziuk et al., 10 Oct 2025). Constraint management ensures security and interpretability.
• Coverage and Filtering: Retrieval aims for high ground-truth coverage, often narrowing candidate sets by 10×–100× compared to open-world retrievals, with hyperparameters set to favor recall in initial stages and precision in downstream tasks (Yang et al., 27 Mar 2025, Ouyang et al., 2024).
• Performance Metrics: Query and indexing times are linear in the number of nodes/edges; system latencies (query and update) are measured in seconds for typical open-source repositories (Serban et al., 2020, Chinthareddy, 13 Jan 2026).

4. Integration with LLM/Large Model Inference and Generation

The RIG acts as the fundamental bridge between repository structure and LLM-driven reasoning or generation:

• RAG/Prompt Augmentation: Retrieved RIG subgraphs are serialized (or summarized) and injected as structured prompt context or into special context windows, enabling LLMs to reason over explicit topological, dependency, or semantic relationships (Tao et al., 22 May 2025, Bevziuk et al., 10 Oct 2025, Athale et al., 20 May 2025, Ouyang et al., 2024, Wang et al., 7 Sep 2025).
• Cross-Attention and Structural Masks: Advanced integration mechanisms inject adjacency-constrained attention into LLMs (e.g., graph-biased causal masks), enabling token-level message passing among structurally related code entities (Tao et al., 22 May 2025, Wang et al., 7 Sep 2025).
• Hierarchical Fusion and Memory Handling: Retrieved code and graph fragments are fused via node- and edge-level attention or aggregated statistics (e.g., GNN readouts, pooled embeddings), preserving multi-level relationships (file, function, call graph, AST, build, test) (Wang et al., 7 Sep 2025).
• Path-Guided and Evidence-Augmented Prompts: Subgraph paths from issue/PR to candidate function/class are rendered as “path_info” fields in LLM prompts, giving the model explicit architectural reasoning chains (Yang et al., 27 Mar 2025).
• Structured JSON Views: For deterministic code assistance, a flattened JSON representation of the RIG is consumed as context, permitting agents to treat the graph as ground truth for build, test, and dependency queries (Cherny-Shahar et al., 15 Jan 2026).

5. Empirical Evaluation and Repository-Level Impact

RIG-centric architectures have been empirically validated on benchmarks spanning code repair, cross-file completion, build/test question answering, bug localization, and retrieval:

• Resolution and Accuracy Gains: State-of-the-art systems using RIGs (KGCompass, CGM, GRACE, RANGER, RepoGraph, SPADE) report substantial gains in issue resolution, localization accuracy, exact match, edit similarity, and reasoning correctness compared to vector-only or text-only baselines (Yang et al., 27 Mar 2025, Tao et al., 22 May 2025, Athale et al., 20 May 2025, Ouyang et al., 2024, Wang et al., 7 Sep 2025, Cherny-Shahar et al., 15 Jan 2026, Bevziuk et al., 10 Oct 2025, Shah et al., 27 Sep 2025, Chinthareddy, 13 Jan 2026).
• Efficiency and Scalability: Indexing and retrieval operate efficiently at the scale of tens to hundreds of thousands of entities, with deterministic extractors (SPADE, AST-based) achieving low-cost, full coverage, and rapid incremental updates even for complex multilingual repositories (Cherny-Shahar et al., 15 Jan 2026, Chinthareddy, 13 Jan 2026). RIGs reduce completion time for complex repository-level questions by 50–70% and improve agent efficiency (seconds per correct answer) proportionally (Cherny-Shahar et al., 15 Jan 2026).
• Coverage and Failure Modes: RIG-augmented agents and systems show marked reduction in structural errors, shifting failures toward higher-level reasoning rather than mistaken structural inference. Deterministic, AST-extracted RIGs consistently outperform LLM-generated graphs in multi-hop architectural queries, corpus coverage, and cost (Chinthareddy, 13 Jan 2026).
• Extensibility and Limitations: RIG schemas and extraction pipelines are extensible to support new language grammars, hybrid build systems, packaging formats, and can incorporate additional semantic or behavioral features as needed (Cherny-Shahar et al., 15 Jan 2026, Serban et al., 2020, Yang et al., 27 Mar 2025). However, graph-based retrieval and reasoning quality remains critical; poorly designed traversal or fusion strategies can lead to incomplete answers even with correct graph data.

6. Classes of RIGs and Comparative Methodology

Distinct RIG variants have been formalized and benchmarked, each optimized for different repository intelligence tasks:

• Source-Level and Version Graphs: Focused on code change mining and history analytics (GraphRepo) (Serban et al., 2020).
• Fine-Grained Line/AST Graphs: Line-level or AST-derived node organization to support precise local reasoning (RepoGraph, DKB) (Ouyang et al., 2024, Chinthareddy, 13 Jan 2026).
• Semantic-Embedding Graphs with Textual Augmentation: Nodes/edges enriched with LLM- or encoder- derived embeddings and generated one-sentence summaries (CGM, RANGER, vector graph-based approaches) (Tao et al., 22 May 2025, Shah et al., 27 Sep 2025, Bevziuk et al., 10 Oct 2025).
• Architectural and Build-Oriented RIGs: Explicitly model buildable, testable, and packaged artifacts, with dependencies, runners, test coverage, and evidence links (SPADE, RIG for build/test) (Cherny-Shahar et al., 15 Jan 2026).
• Multimodal/Heterogeneous Code Graphs: Unification of AST, call, dataflow, type, containment, and inheritance graphs with fine-grained edge typing (GRACE) (Wang et al., 7 Sep 2025).
• Knowledge Graphs Bridging Issues/PR to Code: Explicit integration of software process artifacts (issue, PR) with fine-grained code entity types and path-based scoring (KGCompass, repository-level code repair assistants) (Yang et al., 27 Mar 2025).

Comparative studies consistently show the superiority of deterministic AST/build-based RIGs in structural coverage and architectural reasoning, while hybrid graph–embedding–prompt approaches offer best-in-class performance in retrieval and generative tasks.

7. Outlook, Limitations, and Open Directions

RIGs represent a central organizing abstraction for repository-aware software engineering, enabling interpretable, efficient, and highly accurate LLM code assistance across diverse programming languages, build systems, and repository artifacts. Empirical findings indicate:

• RIG-augmented systems transform brittle file- or chunk-level reasoning into globally coherent, multi-hop, and cross-language analysis.
• The major limitations in RIG-enabled systems are now found in graph traversal, expansion, and prompt/fusion methods—where reasoning strategies struggle, rather than structural blindspots (Cherny-Shahar et al., 15 Jan 2026).
• Automated, deterministic extraction (for both code and build/test infrastructure) is now tractable across mainstream languages and toolchains. Integration of LLM-based summaries and embeddings further reduces the gap between NL and code comprehension (Cherny-Shahar et al., 15 Jan 2026, Tao et al., 22 May 2025, Bevziuk et al., 10 Oct 2025).
• Open challenges include generalizing reasoning patterns across languages, optimizing graph prompt linearization and fusion for LLMs, and extending RIG paradigms to capture dynamic/runtime behavior and multi-repository relations.

In summary, the Repository Intelligence Graph is now an essential backbone for advanced automated software engineering, providing the necessary structure, semantic richness, and operational efficiency for scalable, accurate, and explainable task automation across code repositories (Serban et al., 2020, Tao et al., 22 May 2025, Yang et al., 27 Mar 2025, Bevziuk et al., 10 Oct 2025, Shah et al., 27 Sep 2025, Cherny-Shahar et al., 15 Jan 2026, Athale et al., 20 May 2025, Ouyang et al., 2024, Wang et al., 7 Sep 2025, Chinthareddy, 13 Jan 2026).