RepoGenReflex: Repository Code Completion

• RepoGenReflex is a repository-level code completion framework that uses verbal reinforcement to guide multi-file code generation with iterative feedback.
• It replaces traditional gradient updates with a dynamic control loop that integrates retrieval-augmented generation and linguistic feedback.
• Empirical evaluations demonstrate improved exact match and edit similarity scores over baselines, highlighting its adaptive and scalable design.

RepoGenReflex is a framework for repository-level code completion that introduces a dynamic, verbally reinforced control loop to optimize multi-file code auto-completion across large software repositories. Rather than relying on traditional gradient-based updates, RepoGenReflex iteratively steers retrieval and generation processes using linguistic feedback—termed "verbal reinforcement"—in conjunction with retrieval-augmented generation (RAG). This design supports fast, adaptive convergence to accurate, contextually appropriate code completions at the repository scale (Wang et al., 2024).

1. Conceptual Foundations and Goals

RepoGenReflex was developed to overcome the limitations of conventional code completion tools, which struggle with dynamic optimization of retrieval and generation when reasoning across multiple files and functions. The framework aims to:

• Enhance repository-level code completion without model weight updates.
• Replace backpropagation or RL-style credit assignment with "verbal reinforcement": using LLM-generated feedback to direct the next retrieval/generation iterations.
• Deliver an iterative, adaptive solution that accumulates and acts upon historical feedback, enabling both faster convergence and more relevant completions irrespective of repository complexity.

The architecture is generic and can be instantiated with various retrieval, generation, and feedback models.

2. System Architecture and Iterative Loop

The core workflow proceeds in discrete iterations $\{t\}$. The following components interact at each step, forming a closed-loop process:

1. Retriever (RAG component): For current prompt $\mathcal{P}_t$, retrieve top-$k$ code snippets $\{s_{t,1}, ..., s_{t,k}\}$ from the repository guided by Jaccard similarity on token sets.
2. Actor (LLM-based generator): Concatenate retrieved snippets with the (unfinished) code in $\mathcal{P}_t$; generate a candidate completion $\hat{Y}_t$.
3. Evaluator:
   • Exact Match: $\mathrm{EM}_t = \mathbf{1}\{\hat{Y}_t=Y\}$ (indicator for completion correctness);
   • Edit Similarity: $$\mathrm{ES}_t = 1 - \frac{\mathrm{Lev}(\hat{Y}_t,Y)}{\max(|\hat{Y}_t|,|Y|)}$$, using Levenshtein distance [levenshtein1966binary].
4. Reflector: Receives $\hat{Y}_t$, $\mathrm{EM}_t$, $\mathcal{P}_t$0, prompt $\mathcal{P}_t$1; emits feedback $\mathcal{P}_t$2 including quantitative metrics, syntactic/semantic assessment, and actionable suggestions.
5. Experience Cache: Stores $\mathcal{P}_t$3. On each subsequent iteration, the new retrieval target incorporates selected suggestion lines from $\mathcal{P}_t$4.

A single iteration may be formalized as an update to the prompt, not model parameters:

$\mathcal{P}_t$5

where the updated prompt fuses $\mathcal{P}_t$6 suggestion lines from $\mathcal{P}_t$7 and $\mathcal{P}_t$8 trailing lines from the original task. Retrieval terminates when $\mathcal{P}_t$9, $k$0 plateaus (<1% improvement for 3 consecutive steps), or $k$1.

3. Mathematical Abstraction of RAG–VRL Loop

RepoGenReflex frames each iteration as maximizing an explicit surrogate reward:

$k$2

for $k$3. Feedback directs the subsequent prompt and retrieval process. The overall iteration advances towards maximized $k$4 without any gradient update; the adaptation occurs exclusively at the prompt and retrieval levels.

The experience cache does not require separate indexing: retrieval repeatedly computes the Jaccard overlap

$k$5

between the current $k$6-line prompt-derived set $k$7 and candidate snippet $k$8.

4. Verbal Reinforcement and Experience Cache

The Reflector utilizes an LLM to analyze the generated code against reference completions and evaluator metrics. Its unconditional feedback—quantitative evaluation, contextual/syntactic critique, and forward suggestions—serves as a dynamic, prompt-level control signal. The top $k$9 suggestions from $\{s_{t,1}, ..., s_{t,k}\}$0 feed forward into the retrieval query for the next iteration, guiding the system toward more relevant snippets and better completions.

This experience cache accumulates annotated tuples for each iteration, ensuring that the system benefits from the trajectory of prior feedback and context. The process is reminiscent of RL memory buffers but is utilized exclusively for context and retrieval steering, not for policy learning or value estimation.

5. Empirical Evaluation and Benchmarking

RepoGenReflex was evaluated on the RepoGenEval benchmark featuring modern, real-world Python repositories (e.g., MetaGPT, gpt-pilot, TaskWeaver, Otter; 700–40,000 stars), each with hundreds of files and tens of thousands of lines. For each of eight repositories, 200 non-comment line completions were sampled, yielding 1600 test scenarios.

Experimental setup highlights:

• Actor: CodeGen-Mono-6B [nijkamp2022codegen].
• Reflector Models: CodeGen-Mono-6B (Model A) and Meta-Llama-3-8B (Model B).
• Baselines: CodeT5+ 2B, CodeLlama-7b-hf, StarCoder, CodeGemma (7B).
• Metrics: Exact Match (EM), Edit Similarity (ES).

Key quantitative results:

Setting / Model	EM (RepoEval)	ES (RepoEval)	EM (RepoGenEval)	ES (RepoGenEval)
RepoGenReflex (Meta-Llama-3-8B Reflector)	≈0.48	≈0.754	≈0.439	≈0.735
Next best (CodeGemma)	≈0.463	≈0.746	≈0.436	≈0.721
Ablation: no Reflector/Exp.	≈0.352	≈0.648	–	–
Ablation: no Evaluator	≈0.430	≈0.738	–	–

Reflector model choice is significant: Meta-Llama-3-8B as Reflector yields an absolute +3–5 percentage point EM and +0.04–0.05 ES gain over CodeGen-Mono-6B (Wang et al., 2024).

Qualitative analysis illustrates that, relative to baseline LLMs, the Reflector can identify missing error handling or type mismatches and direct retrieval or generation, leading to correct stubs or logic on subsequent iterations.

6. Relationship to the RePro Framework and Reflective Paper-to-Code Reproduction

The RePro architecture (Zhou et al., 21 Aug 2025) targets end-to-end paper-to-code reproduction by extracting atomic "fingerprint" criteria from scientific papers and iteratively refining code until all criteria pass fine-grained verification. RepoGenReflex inherits several of these core reflective elements:

• Systematic, fine-grained feedback loop, replacing gradient updates with explicit, multi-level linguistic criteria and suggestions.
• Hierarchical guide/fingerprint extraction and verification of modular implementation constraints.
• Experience cache/criteria memory for long-range credit assignment and cumulative improvement.

RepoGenReflex extends these ideas to the repository scale and completion context, robustly handling cross-file, multi-line suggestions, retrieval targets, and repository structure, while employing retrieval-augmented generation and verbal reflection as its interactive optimization mechanisms.

A plausible implication is that future extensions of RepoGenReflex may directly leverage multi-modal or multi-level verification, integration with static analysis, or direct invocation of unit/integration tests as part of the experiential cache and reflection loop, echoing RePro's approach to paper fidelity and full-pipeline reproducibility.

7. Limitations, Research Extensions, and Broader Applicability

RepoGenReflex exhibits several limitations:

• Dependence on high-quality Reflector LLMs; feedback quality is degraded by hallucinated or imprecise suggestions.
• Jaccard retrieval may miss semantically similar but lexically dissimilar code snippets.
• No theoretical convergence guarantee or formal RL objective.

Future work is outlined as:

• Integration of embedding-based or neural retrievers for semantically meaningful context selection.
• Hybrid models that combine gradient updates with verbal feedback.
• Extension to function/body-level, cross-lingual, or multi-modal code completion scenarios.

Broader applicability includes zero-shot generalization to entirely unseen repositories due to the verbal reinforcement paradigm, and potential translation of the core methodology to domains such as document-level question answering by treating passages as "code" and leveraging the same iterative RAG-VRL-feedback loop (Wang et al., 2024).

RepoGenReflex thus exemplifies a convergence of retrieval-augmented generation, verbal reflection, and experience-driven adaptation for dynamic, scalable code completion, setting a template for further advances in agent-based code intelligence and reproducibility.