RPG-Encoder Framework

• RPG-Encoder is a computational framework that encodes rich, domain-specific data into a Repository Planning Graph (RPG) for robust reasoning and navigation.
• It employs a prompt-based pipeline for code analysis, deterministic algorithms for watermarking, and learned models for avatar parameter extraction.
• Empirical evaluations demonstrate its effectiveness in repository reconstruction, watermark integrity, and enabling bidirectional mappings for LLM agents.

RPG-Encoder refers to several distinct computational frameworks united by the core notion of converting rich, nontrivial information—be it program watermarks, repository structure, or game avatar semantics—into or from an intermediate graph-based representation named a Repository Planning Graph (RPG). Contemporary systems branded “RPG-Encoder” address structurally and semantically diverse domains, including codebase representation for LLM agents, software watermarking, and machine perception for role-playing game (RPG) avatar synthesis. Foundational approaches emphasize efficient, bidirectional mapping between symbolic, semantic, or behavioral data and a formalized RPG structure, enabling robust reasoning, navigation, generation, and extraction.

1. Formal Definitions and Theory of Repository Planning Graphs

The RPG is a heterogeneously typed, attributed directed graph designed to encode complex hierarchical, functional, and data-flow properties of software repositories or structured information artefacts. In its most general form, the RPG is formalized as the tuple

$$\mathcal{G} = (\mathcal{V},\,\mathcal{E}_{\mathrm{feature}},\,\mathcal{E}_\mathrm{dep}),$$

where $\mathcal{V} = \mathcal{V}_H \cup \mathcal{V}_L$ partitions nodes into high-level (e.g., functional centroids, directories) and low-level entities (files, classes, functions). Nodes carry semantic feature embeddings $f_v\in\mathbb{R}^d$ and structured metadata $\mathbf{m}_v$ (entity type, source localization). Functional edges ($\mathcal{E}_{\mathrm{feature}}$) encode hierarchical or teleological structure (parent/child, module decomposition), while dependency edges ($\mathcal{E}_{\mathrm{dep}}$) capture static or semantic coupling (imports, calls, inheritance) (Luo et al., 2 Feb 2026).

This graph-centric formalism underpins agent navigation, reverse-engineering, and blueprint-based code generation. In watermarking, a variant of the RPG emerges as a reducible permutation graph $F[\pi^*]$ bijectively encoding self-inverting permutations, guaranteeing both algebraic invertibility and flow-graph reducibility (Chionis et al., 2014, Mpanti et al., 2016).

2. Encoding Methodologies Across Domains

a. Repository Comprehension and Generation

In modern LLM-driven agent systems, RPG-Encoder operates as a prompt-driven pipeline that extracts RPGs from raw source code with minimal manual supervision. Extraction follows three phases:

1. Semantic Lifting: AST-driven enumeration of functions/classes, each annotated with atomic features elicited from LLMs.
2. Semantic Structure Reorganization: Synthesis of higher-level feature centroids and folder hierarchies, recursively assigning leaves to semantically compatible parents.
3. Artifact Grounding: Bottom-up propagation of file paths and injection of empirical dependency edges.

The resulting RPG is serialized (typically as JSON) and directly provided as context to a transformer LLM, empowering bidirectional intent–implementation traversal—thereby “closing the reasoning loop” for repository agents (Luo et al., 2 Feb 2026). No neural graph encoder, GNN, or learned message-passing module is employed at this stage—prompt engineering dictates schema and edge semantics (Luo et al., 19 Sep 2025, Luo et al., 2 Feb 2026).

b. Watermark Encoding via Permutation Graphs

The RPG-Encoder for software watermarking adopts a purely algorithmic (non-learned) approach. Given a $n$-bit watermark integer $w$, the encoder:

• Constructs a bitonic self-inverting permutation $\pi^*$ of length $2n+1$ using a deterministic bit-marking and pairing scheme.
• Maps $\pi^*$ to a reducible flow-graph $F[\pi^*]$, realizing the RPG as a unique directed acyclic graph with forward and backward “domination” edges, exhibiting out-degree at most two. This process is bijective and fully invertible, enabling rapid encoding and extraction with $O(n)$ time and space (Chionis et al., 2014, Mpanti et al., 2016).

c. Game Avatar Parameter Extraction

In the EasyCraft pipeline, the RPG-Encoder concept refers to a “translator” that maps photo or text cues to an engine’s avatar parameter manifold. Its encoder comprises:

• A Masked Autoencoding Vision-Transformer, $\mathcal{T}_e$, pretrained for style-agnostic representation.
• Three parallel MLP heads, $\mathcal{T}_p$, projecting the [CLS] token embedding to discrete and continuous facial/makeup parameter spaces.

Photo inputs proceed through patch masking and ViT feature extraction; text prompts are first rendered as style-aligned images using fine-tuned Stable Diffusion, then routed through the same ViT+MLP sequence. No explicit graph is constructed, but the “encoder” terminology is retained for continuity with the graph-driven regimes (Wang et al., 3 Mar 2025).

3. Absence of Trainable Neural Graph Modules in LLM Code Generation Frameworks

In LLM-driven repository generation (not watermarking or EasyCraft), there is no implemented or described mechanism for a message-passing graph neural network or transformer architecture operating over the RPG. Unlike neural graph encoders (e.g., MPNN or Graph Attentions), no layer-wise updates, learnable node/edge embeddings, or supervised losses exist. Instead, the RPG is serialized as JSON and concatenated into the LLM’s prompt; graph structural reasoning is offloaded to the LLM’s native transformer self-attention mechanism, which attends over the textual representation. This constrains all “encoding” to prompt engineering and model context, with no differentiable intermediate module (Luo et al., 19 Sep 2025).

4. Incremental Maintenance and Structure-Aware Tooling

RPG-Encoder as a bidirectional repository abstraction supports low-overhead, incremental updates and structure-aware navigation:

• Topology Evolution: Updates for insertions, deletions, and modifications operate only on affected subgraphs, leveraging semantic drift thresholds and path-grounded directory assignment via Trie-based LCA algorithms, decoupling maintenance cost from total repository size by up to 95.7% (Luo et al., 2 Feb 2026).
• Unified API: Structure-aware “SearchNode,” “FetchNode,” and “ExploreRPG” operations interleave intent-based (semantic feature) and dependency-based queries, supporting granular navigation, verification, and code extraction. These primitives facilitate accurate code localization, minimize navigation steps and enable robust recovery/fidelity of repository structure from the RPG abstraction.

5. Empirical Evaluation and Comparative Performance

RPG-Encoder demonstrates state-of-the-art results across multiple benchmarks:

• Repository Understanding: On SWE-bench Verified, RPG-Encoder attains 93.7% Acc@5, exceeding the best baseline by 14.4 points (Precision 83.4%, Recall 75.8%).
• Repository Reconstruction: On RepoCraft, RPG-Encoder achieves 98.5% coverage and an 86% test-pass rate, reconstructing nearly the full codebase token volume (Luo et al., 2 Feb 2026).
• Watermark Graphs: RPG-flowgraph encodings preserve injectivity and resilience, permitting multiple non-isomorphic embeddings of a single integer watermark, and supporting robust defense against graph-based transform attacks (Chionis et al., 2014, Mpanti et al., 2016).
• Game Avatar Crafting: The RPG-Encoder in EasyCraft achieves superior accuracy and speed in both photo-based and text-based avatar parameter inference, outperforming specialized baselines in identity preservation, text alignment, and user preference (Wang et al., 3 Mar 2025).

6. Limitations and Future Directions

Current RPG-Encoder instantiations in repository domains are fundamentally prompt-driven, relying on LLM-based schema adherence and language-specific AST toolchains. Semantic shift thresholds require manual calibration and do not leverage end-to-end, self-supervised graph representation learning—no GNN or differentiable graph module is present. Language coverage remains limited (e.g., Python-only extraction) and does not yet integrate runtime or dynamic analysis into dependency extraction. Future directions focus on incorporating GNN-based end-to-end graph embeddings, expanding to multilingual settings, and enabling active RL-based agents leveraging RPG as a working environment graph (Luo et al., 2 Feb 2026).

In watermarking, the codec system is highly efficient and resilient but operates in a closed setting anchored to flow-graph permutations and may require adaptation for adversarial program structures (Chionis et al., 2014, Mpanti et al., 2016). In the context of avatar parameter extraction, ablation demonstrates necessity of MAE pretraining and engine-specific text-to-image front ends; architectural regularization and domain adaptation are potential areas for investigation (Wang et al., 3 Mar 2025).

7. Schematic Comparison of RPG-Encoder Variants

Application Domain	RPG-Encoder Instantiation	Nature of Encoding
LLM codegen/planning (ZeroRepo)	Prompt-based serialization	Non-learned, prompt-encoded
Repository Representation (2026)	LLM+AST-driven, incremental update	Rule-based, LLM-in-context
Watermark flowgraph encoding	Algebraic codec (SiP→RPG)	Deterministic, invertible
RPG avatar parameter extraction	MAE-ViT + MLP (EasyCraft)	Learned, supervised

Each instantiation reflects different trade-offs in expressivity, invertibility, scalability, and learning-based adaptation, but all employ RPGs as core structural or semantic intermediates.