CoRaCommit: A VS Code Extension for Commit Message Generation with Exemplar Retrieval Chaoran Cai1 , Bo Xiong1 , Chong Wang2 , Lulu He2 , Peng Liang
arXiv:2606.19814v1 [cs.SE] 18 Jun 2026
School of Computer Science, Wuhan University, 430072, China
Abstract Commit messages are essential textual artifacts that describe the intent behind code changes, and play a critical role in version control, code review, and historical tracking. However, in practice, commit messages are primarily authored manually, which is time-consuming and often results in inconsistent quality and non-uniform expression. Existing VS Code extensions for commit message generation typically directly invoke large language models based on the code diff, without leveraging similar commit exemplars as references, and rarely support user feedback-driven LLM recommendation. To address these limitations, this paper proposes CoRaCommit, a VS Code extension that enhances commit message generation by retrieving similar commit exemplars as prompt context, invoking multiple LLMs in parallel for candidate commit message comparison, and dynamically recommending LLMs based on user feedback. Experimental results on 945 commits from the ApacheCM dataset show that CoRaCommit outperforms existing VS Code extensions across BLEU, CIDEr, METEOR, and ROUGE-L metrics, demonstrating the effectiveness of retrieval-augmented context for commit message generation. Keywords: Software Maintenance, Commit Message Generation, Retrieval-Augmented Generation, VS Code Extension, Model Recommendation Metadata Table 1 is the ancillary data table required for the codebase of the extension, and the left column is required to be untouched. 1
Chaoran Cai and Bo Xiong contributed equally to this work. Chong Wang and Lulu He are the corresponding authors. Corresponding emails: [email protected], [email protected]. 2
Table 1: Code metadata (mandatory)
Nr. C1 C2 C3 C4 C5 C6 C7
C8 C9
Code metadata description Current code version Permanent link to code/repository used for this code version Permanent link to Reproducible Capsule Legal Code License Code versioning system used Software code languages, tools, and services used Compilation requirements, operating environments and dependencies If available, link to developer documentation/manual Support email for questions
Please fill in this column V2.1 https://github.com/T-rresa/CoRaCMG N/A MIT License git TypeScript, JavaScript and Python VS Code, NPM, Node.js, FastAPI, Docker
1. Introduction Commit messages describe the purpose and content of code changes and play a critical role in software maintenance and collaborative development. Clear and well-structured commit messages help developers quickly understand the intention of code modifications, improve the efficiency of code review, and serve as a vital reference for downstream maintenance tasks such as bug localization and version release management. However, in practice, developers often prioritize implementing features and fixing bugs over documentation. Consequently, commit messages are frequently missing or lack sufficient details [1], reducing the readability of commit messages themselves and the utility of project history for tasks such as bug localization, version release, and historical tracking. As large language models (LLMs) continue to advance in code understanding and text generation, automatically generating commit messages from code changes has emerged as a practically significant research topic. 2
Existing IDE-integrated commit message generation (CMG) extensions have demonstrated the feasibility of generating commit messages directly within development environments, such as Auto Commit Message 3 , AI Commit 4 , and Commit Sage 5 . However, most extensions rely solely on the current code diff as generation input and provide little support for assisting users in selecting among multiple available LLMs. These limitations motivate the design of CoRaCommit, a VS Code CMG extension that augments LLM with retrieved commit exemplars. CoRaCommit adopts the CoRaCMG [2], a contextual retrieval-augmented framework that uses a hybrid retriever combining semantic vectors and BM25 to retrieve similar commit exemplars (i.e., historical diff-message pairs) from the ApacheCM commit dataset [3] and augments the input prompt with these pairs to guide LLM-based CMG. Beyond this core framework, CoRaCommit provides three key capabilities for IDE-based scenarios: (a) concurrent invocation of multiple LLMs to facilitate candidate comparison; (b) asynchronous feedback-driven evaluation that updates both global and exemplarlevel LLM scores based on user selection and editing behavior; and (c) dynamic LLM recommendation, including both a global ranking and taskspecific suggestions based on retrieved similar commit exemplars. By leveraging external commits and user feedback, CoRaCommit provides developers with higher-quality commit messages that are better aligned with the current code changes. The main contributions of this paper are summarized as follows. • We design and implement CoRaCommit, a VS Code extension adopting CoRaCMG framework [2] for automated CMG. It incorporates staged code diff extraction, hybrid retrieval of similar commit exemplars from ApacheCM, and retrieval-augmented generation to deliver candidate commit messages within practical development workflows. • An LLM evaluation and recommendation mechanism is designed and implemented in CoRaCommit to facilitate informed LLM selection for CMG tasks. The proposed mechanism updates both global and exemplarlevel LLM scores based on candidate generation results, user selections, and finally adopted commit messages, thereby supporting both global LLM ranking display and task-specific LLM recommendation. • Comparative experiments are performed against existing VS Code CMG 3
https://github.com/MichaelCurrin/auto-commit-msg https://github.com/sitoi/ai-commit 5 https://github.com/VizzleTF/CommitSage.git 4
3
extensions to evaluate the quality of commit messages generated by CoRaCommit. The remainder of this paper is organized as follows. Section 2 presents related work. Section 3 introduces the system architecture and workflow of CoRaCommit. Section 4 presents the four core features of CoRaCommit. Section 5 presents the results of the experimental evaluation. Section 6 concludes the paper and outlines the future work. 2. Background and Related Work 2.1. Commit Message Generation Research on CMG has progressed through neural machine translation approaches, structured code representation methods, and large language model approaches. Early research primarily modeled the mapping between code diffs and commit messages as a sequence-to-sequence translation problem, treating code diffs as source sequences and commit messages as target sequences [4]. Subsequent work further introduced copy mechanisms, abstract syntax trees and other structural information [5, 6], and input condensation methods to enhance the LLM’s ability to handle function names, variable names, key terms, and core change content [7]. In recent years, LLMs have demonstrated significant advantages in code understanding and natural language generation tasks, propelling CMG into a new phase. Existing studies indicate that LLMs can generally improve the quality of generated commit messages [8]. To address the insufficient use of context by LLMs, retrieval-augmented generation methods have been introduced into CMG tasks [9]. These methods provide additional context for the generation process by incorporating relevant examples. For CMG tasks, similar commit exemplars from historical commits can offer expression patterns and terminology information related to the current code diff, thereby helping LLMs better understand the intent behind the modification. For example, CoRaCMG proposes a hybrid retrieval strategy that combines semantic and lexical similarity to retrieve relevant commit exemplars from the historical repository [2]. 2.2. VS Code Extensions for Commit Message Generation Several VS Code extensions now support commit message generation. Table 2 compares these extensions with CoRaCommit. Auto Commit Message primarily relies on the predefined templates and rules to generate commit messages based on file changes. It generates messages in the format <type>[scope]: <description>. Specifically, the tool 4
Table 2: Comparison of CoRaCommit with Existing VS Code Extensions for Commit Message Generation VS Code Extensions Generation approach Requires external LLM API key? Input source
Auto Commit Message Template Rule
&
N/A Changed list
support for N/A multiple LLMs Feedback-driven N/A LLM recommendation
file
AI Commit
Commit Sage
LLM-based
LLM-based
RAG & LLMbased
Yes
Yes
Yes
Git code diff
Git code diff
Git code diff
Yes
Yes
Yes
No
No
Yes
CoRaCommit
analyzes file changes to determine the TYPE and optional SCOPE, while the DESCRIPTION is generated by predefined rules that describe what has been created, updated, or renamed. Auto Commit Message offers straightforward usage and lower implementation costs, but its generation results depend heavily on predefined rules and exhibit limitations in expressive flexibility and semantic adaptability. AI Commit uses LLMs to generate commit messages from the current code diff. It supports invoking different LLMs to generate Conventional Commits-style commit messages based on the current code diff, providing features such as multi-language support and prompt configuration. Compared to rule-based methods, these extensions offer stronger language expression capabilities, but their generation workflows still primarily revolve around the current code diff. Commit Sage is another VS Code extension that uses LLMs to generate commit messages. It supports multiple AI providers, commit formats, and project-level configurations. This extension advances further in configurability and engineering usage patterns, but its core workflow still primarily involves analyzing the current code diff and generating commit messages without leveraging similar commit exemplars as references. As highlighted above, existing VS Code CMG extensions exhibit two limitations: first, they rely exclusively on the current code diff for generation, without leveraging similar commits as contextual references; second, they lack support for LLM recommendation when multiple LLMs are available. To address these limitations, this paper introduces CoRaCommit, a VS Code extension that incorporates both retrieval-augmented generation and 5
an adaptive LLM evaluation and recommendation mechanism. Specifically, its retrieval component implements the hybrid retrieval strategy proposed by CoRaCMG [2]. In parallel, CoRaCommit leverages external commit exemplars and historical LLM performance feedback to jointly improve the quality of generated commits and support adaptive LLM selection. 3. Overview CoRaCommit is designed to seamlessly integrate into developers’ daily commit workflows within VS Code by providing high-quality candidate commit messages without imposing significant extra effort. This section outlines the overall design of CoRaCommit, including its system architecture and workflow of generating commit messages and feedback-driven evaluation. 3.1. System Architecture To support interactivity, extensibility, and efficiency in IDE-based workflows, CoRaCommit adopts a layered architecture comprising a VS Code extension frontend, a Node.js service orchestration layer, a Python-based retrieval and evaluation backend, and a foundational data and state management layer. The system architecture of CoRaCommit is shown in Figure 1.
Figure 1: System Architecture of CoRaCommit
More specifically, the VS Code extension frontend extracts staged code diffs from the current repository, reads user configurations, presents similar 6
commit exemplars and candidate commit messages, and submits feedback after user confirmation. To reduce irrelevant context and mitigate potential privacy risks, CoRaCommit performs lightweight input preprocessing on the client side. The frontend is intentionally designed to remain lightweight and responsive, avoiding complex computation and delegating retrieval, generation, and evaluation tasks to backend services. The Node.js service orchestration layer handles requests from the extension and coordinates the key processing steps. These steps include retrieving similar commit exemplars, constructing prompts, invoking multiple LLMs concurrently, aggregating results, and enqueueing feedback evaluation tasks for asynchronous processing. In our implementation, this layer is divided into an online API process and a background worker process. The online API process serves extension requests and returns candidate commit messages with low latency, while the background worker consumes feedback evaluation tasks and updates LLM scores asynchronously. Positioned between the extension frontend and the computation services, this layer orchestrates both the online generation pipeline and the asynchronous scoring pipeline. The Python-based retrieval and evaluation backend retrieves similar commit exemplars and evaluates candidate commit messages generated by the LLMs. It consists of two FastAPI endpoints: Retrieval and Evaluation. The Retrieval endpoint handles vector encoding, candidate retrieval, and reranking, while the Evaluation endpoint performs multi-metric scoring of candidate commit messages. The data and state layer stores the ApacheCM commit dataset, index files, LLM scores, and user feedback logs. It also maintains queues, caches, and runtime state information to support retrieval lookup, score persistence, queue consumption, and ranking-cache operations. 3.2. Workflow of CoRaCommit The workflow of CoRaCommit is illustrated in Figure 2. CoRaCommit begins by extracting the staged code diff from the current repository and performing lightweight local preprocessing. The developer then specifies the target language, the commit message format, and the selected LLMs through the configuration panel shown in Figure 3a, while the leaderboard interface in Figure 3b offers supplementary guidance for selecting an appropriate LLM. Based on these settings, the extension sends a generation request to the backend, where the retrieval service searches the ApacheCM dataset for similar commit exemplars. The service orchestration layer combines the processed code diff, retrieved exemplars, and user configurations to construct prompts, and invokes one or more LLMs in parallel to generate candidate commit messages, which are then presented to the developer for selection, as shown in 7
Figure 4. Once the developer selects or edits a candidate commit message and confirms the commit, CoRaCommit records the interaction as feedback. Subsequently, the background worker process invokes the evaluation service without blocking the online generation pipeline, scores the candidate commit messages, and updates both the global scores of the invoked LLMs and the exemplar-level LLM scores. The updated scores are then reused in subsequent generation tasks, forming a feedback loop among retrieval, generation, evaluation, and recommendation. BM25 Rerank Vector Retrieve Click “Generate”
Developer
Code Diff
Construct
ChatGPT DeepSeek
Exemplars
Qwen Construct
Generate
Prompt
Recommend LLM
Select & Edit
Generated Commit Message Final Commit Messages Commit Message
Evaluate LLM with Collected Feedback
LLM Performance Score
Figure 2: Workflow of CoRaCommit
(a) Generation configuration interface.
(b) LLM leaderboard interface.
Figure 3: Generation configuration and LLM recommendation interface in CoRaCommit.
8
Figure 4: Candidate commit message selection interface.
Consider a representative scenario where a developer modifies the function calculateTotal() to handle null inputs and stages the corresponding change in Git. CoRaCommit first extracts and preprocesses the staged code diff, and then presents the processed diff for user inspection. Next, the developer specifies the generation settings by selecting English as the target language, Conventional Commits as the message format, and three candidate LLMs. After the developer clicks on “Generate”, CoRaCommit retrieves similar commit exemplars such as “fix: handle edge cases in payment processing”, constructs prompts with these exemplars, and generates three candidate commit messages. For example, candidates may include “fix: add null check in calculateTotal ”, “fix: handle null values in calculateTotal function”, and “refactor: improve null safety in calculateTotal ”. If the developer selects the second candidate and makes minor edits before committing, CoRaCommit records this interaction as feedback and updates the corresponding LLM scores asynchronously. 4. Core Features of CoRaCommit This section details the four core features of CoRaCommit: staged code diff extraction, hybrid retrieval-augmented generation, concurrent invocation of multiple LLMs, and dynamic LLM evaluation and recommendation. In this section, our VS Code extension is referred to as CoRaCommit. 4.1. Staged Code Diff Extraction To ensure high-quality of subsequent retrieval and generation, the extension first preprocesses the Git staged diff on the client side within the VS Code extension before sending it to backend services. This preprocessing aims to minimize input noise and mitigate privacy leakage risks. The process begins by obtaining the code diff content from the staged area of the current repository using git diff –cached. The extension then applies preprocessing operations including line ending normalization to handle cross-platform encoding inconsistencies, binary patch filtering to remove 9
non-textual content, sensitive information masking for API tokens and credentials, and length control to respect context window limitations. By performing these steps on the client side, the extension ensures that the code diff content delivered to downstream components is clean, safe, and appropriately sized. As shown in Figure 5, the processed code diff is displayed in the sidebar for user inspection.
(b) Retrieved similar commit exemplars in sidebar
(a) Processed code diff
Figure 5: Processed code diff and retrieved similar commit exemplars in sidebar
4.2. Hybrid Retrieval-Augmented Generation To provide LLMs with relevant context beyond the current code diff, the extension adopts a hybrid retrieval approach targeting the ApacheCM commit dataset. The system first encodes the current code diff into dense vector representations using CodeBERT [10] or jina-embeddings-v2-base-code embedding models and performs semantic recall based on vector indices to obtain candidate exemplars. Subsequently, these candidates are reranked using BM25 scores to enhance sensitivity to local text features such as function names and path names. This two-stage hybrid retrieval approach balances semantic relevance and keyword matching. During generation, the top-k similar commit exemplars from ApacheCM are organized into a prompt as reference context for CMG. Similar commit exemplars are also displayed in the sidebar for user inspection (see Figure 5). 4.3. Concurrent Invocation of Multiple LLMs The extension supports the parallel invocation of multiple LLMs to generate diverse candidate commit messages, enabling developers to compare alternatives and select the most appropriate one. 10
LLM invocation abstraction. The Node.js service orchestration layer provides a unified abstraction for LLM invocation, supporting OpenAI-compatible API calls and proxy routing. Each invocation encapsulates an LLM identifier, API credentials, and proxy configuration. Parallel generation. When multiple LLMs are configured, the orchestration layer concurrently invokes all selected models. This minimizes total waiting time, since the overall latency depends on the slowest response. Result aggregation. Once all responses have been received, the orchestration layer aggregates the results into a unified format. Each candidate includes the LLM identifier, generated content, and duration of commit generation. 4.4. Dynamic LLM Evaluation and Recommendation To support more informed LLM selection, the extension provides dynamic LLM evaluation and recommendation. After each commit message is confirmed, the system dynamically updates LLM scores based on user feedback, including candidate selection and editing behavior. This asynchronous update refines LLM scores in near real time without blocking the online generation workflow, as illustrated in Figure 6. For a CMG task involving the candidate LLM set M , the system first computes the similarity of the contents between each candidate commit message generated by the LLM and the adopted commit message. The similarity score SimScorem is obtained by the weighted combination of semantic and lexical similarity. Additionally, the system constructs a preference score PreferenceScorem based on user selection and editing behavior: direct adoption yields a higher score, adoption with edits yields a medium score, and unselected candidates receive a lower score. These metrics are fused into a single LLM score: SingleScorem = ws × SimScorem + wp × PreferenceScorem
(1)
To mitigate the influence of differences in task complexity, the system normalizes the scores relative to the highest SingleScore within the same candidate round, yielding CompareScorem . The final score integrates both metrics: FinalScorem = λ × SingleScorem + (1 − λ) × CompareScorem
(2)
The system then applies exponential moving average to update the global LLM score: GlobalScoretm = γ × FinalScoretm + (1 − γ) × GlobalScoret−1 m 11
(3)
Final Message
fix(server): add error logging for json parse failures Candidates { "model": "gpt-4o", "message": "fix(server): add error logging for json parse failures" },{ "model": "qwen-plus", "message": "fix: handle json parse error logging" }
Single Score Calculate Similarity
Comparison Score:
Semantic Lexical
User Preference
Final Score:
is_selected is_edited
User Feedback Update Score（EMA）
"selected_model": "gpt-4o", "is_edited": true
Update score for each example-model pair used
Context
Update score for each model used
"example_ids": [103, 53714]
Input
Evalution & Update
Figure 6: Evaluation and Score Update Process of CoRaCommit
where γ denotes the update coefficient. EMA preserves historical information while weighting recent feedback more heavily, making it suitable for scenarios where LLM versions and task distributions evolve over time. Beyond global scoring, the system also maintains exemplar-level LLM scores that record the performance of each LLM on specific similar commit exemplars. Specifically, exemplari -LLMj denotes the score of LLM j on historical generation tasks where exemplar i served as the prompt context. Upon receiving a new generation request, the system first retrieves a set of similar commit exemplars based on the current code diff and computes the similarity score between the code diff of each exemplar and the current code diff. Subsequently, the system retrieves the corresponding exemplar-level LLM scores for these exemplars and performs a weighted aggregation of each LLM’s historical performance on this exemplar set, using exemplar similarity as the weight. Based on this aggregation, the system generates a task-specific LLM recommendation. 12
These four features jointly support the main workflow of the extension. 5. Experimental Evaluation To verify the effectiveness of CoRaCommit in CMG tasks, this paper conducts comparative experiments primarily from the perspective of generation quality, comparing CoRaCommit with existing VS Code CMG extensions on a unified sample set. The experimental dataset comprises 945 commits randomly sampled from the ApacheCM commit dataset. Each sample in the dataset contains the code diff content and human-written reference commit message. All extensions are evaluated on the same samples with a unified automatic evaluation process for metric calculation. For LLM-based extensions including AI Commit, Commit Sage, and CoRaCommit, the experiments uniformly use deepseek-chat as the external generation LLM, with generation language set to English. CoRaCommit is uniformly configured with Conventional Commits [11] style for all samples, retrieving similar commit exemplars from the ApacheCM commit dataset as prompt context during the generation phase. To ensure a fair evaluation, when retrieving similar commit exemplars for CoRaCommit during the generation phase, the system explicitly excludes the sample itself from the candidate set. The experiments employ four metrics, i.e., BLEU [12], CIDEr [13], METEOR [14], and ROUGE-L [15], to measure the quality of generated commit messages in terms of lexical matching, key information coverage, semantic consistency, and overall expression structure. These metrics are widely adopted in natural language generation (NLG) tasks and have been demonstrated to offer complementary perspectives for evaluation. To ensure comparability with prior work, recent studies on CMG have consistently adopted this evaluation protocol [16, 2]. The corresponding experimental results are presented in Table 3. Table 3: Experimental Comparison of CoRaCommit with Existing VS Code Extensions for Commit Message Generation
Extension Auto Commit Message AI Commit Commit Sage CoRaCommit
BLEU 2.13 1.66 2.39 5.28
CIDEr 0.036 0.002 0.021 0.432
METEOR 1.31 17.12 19.06 21.40
ROUGE-L 6.37 11.18 14.18 20.92
From the BLEU and CIDEr metrics, CoRaCommit achieves 5.28 and 0.432 respectively, both higher than the three compared extensions, indicating that its generation results are closer to human-written reference commit 13
messages in terms of local lexical matching and key information coverage. The improvement in CIDEr is particularly notable, suggesting that CoRaCommit better summarizes the core content of code modifications. This result may be attributed to its retrieval of similar commit exemplars from ApacheCM before generation, where the external commits provide the LLM with additional modification expressions and task clues. On METEOR and ROUGE-L metrics, CoRaCommit achieves 21.40 and 20.92 respectively, also maintaining the best performance. These results indicate that commit messages generated by CoRaCommit not only have advantages in keyword coverage but are also closer to human reference text in semantic consistency, natural language expression, and overall sentence structure. In contrast, although AI Commit and Commit Sage also rely on LLMs and perform better than rule-based extensions on METEOR, their coverage of modification intent and key information remains insufficient due to primarily generating directly from the current code diff. Overall, Auto Commit Message shows relatively weak overall performance across all four metrics, indicating that while rule-based or template-based methods have lower usage costs, they struggle to adapt to complex and diverse code changes. AI Commit and Commit Sage perform relatively better on semantic relevance metrics, demonstrating the advantages of LLMs in natural language generation. Among these extensions, Commit Sage is the strongest baseline after CoRaCommit, yet it still trails CoRaCommit in BLEU, CIDEr, and ROUGE-L. Overall, the results in Table 3 indicate that by introducing similar commit exemplars as retrieval-augmented context, CoRaCommit can generate commit messages more accurately and completely based on code changes. 6. Conclusions and Future Work This paper presents CoRaCommit, a retrieval-augmented commit message generation extension for VS Code. CoRaCommit unifies staged diff preprocessing, hybrid retrieval from the ApacheCM commit dataset, concurrent invocation of multiple LLMs, and dynamic LLM evaluation and recommendation within a single workflow. By incorporating similar commit exemplars as retrieval-augmented context, CoRaCommit helps LLMs generate commit messages that better reflect the intent and content of code changes. The comparative evaluation shows that CoRaCommit outperforms existing VS Code CMG extensions on BLEU, CIDEr, METEOR, and ROUGE-L, indicating the effectiveness of exemplar-based context retrieval for improving commit message quality. In addition, the feedback-driven LLM recommendation component supports both global LLM ranking and task-specific rec14
ommendations by updating LLM scores based on users’ selection and editing behavior. Despite the promising results, several limitations still exist and leave room for future improvement. First, the effectiveness of retrieval-augmented generation depends on the coverage and quality of the ApacheCM commit dataset, and limited dataset coverage may reduce the usefulness of similar commit exemplars for some code changes. Second, retrieval efficiency requires further optimization when the commit dataset becomes larger or when the system faces higher-concurrency usage scenarios. Third, dynamic LLM evaluation and recommendation require sufficient historical feedback data before global scoring, exemplar-level LLM scoring, and task-specific LLM recommendation can become stable and reliable. Future work will therefore focus on improving retrieval efficiency, expanding the commit exemplar corpus, developing more fine-grained recommendation strategies that better capture task characteristics, and conducting larger-scale user studies to evaluate CoRaCommit’s usability and the practical effectiveness of feedback-driven LLM recommendation. References [1] Y. Tian, J. Lawall, D. Lo, What makes a good commit message?, in: Proceedings of the 26th IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER), IEEE, 2019, pp. 1–12. 1 [2] B. Xiong, L. Zhang, Z. Ren, C. Wang, P. Liang, Coracmg: Contextual retrieval-augmented framework for commit message generation, Information and Software Technology 196 (2026) 108169. 1, 2.1, 2.2, 5 [3] B. Xiong, L. Zhang, C. Wang, P. Liang, Contextual code retrieval for commit message generation: A preliminary study, in: Proceedings of the 19th ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM), IEEE, 2025, pp. 358–364. 1 [4] S. Jiang, C. McMillan, Automatically generating commit messages from diffs using neural machine translation, in: Proceedings of the 39th International Conference on Software Engineering (ICSE), IEEE, 2017, pp. 109–119. 2.1 [5] Q. Liu, Z. Liu, H. Zhu, et al., Generating commit messages from diffs using pointer-generator network, in: Proceedings of the 16th International Conference on Mining Software Repositories (MSR), IEEE, 2019, pp. 25–35. 2.1 15
[6] S. Liu, C. Gao, S. Chen, L. Y. Nie, Y. Liu, Atom: Commit message generation based on abstract syntax tree and hybrid ranking, IEEE Transactions on Software Engineering 48 (5) (2022) 1800–1817. 2.1 [7] H. Kuang, N. Zhang, H. Gao, X. Zhou, W. K. G. Assuncao, X. Ma, D. Shao, G. Rong, H. Zhang, Brevity is the soul of wit: Condensing code changes to improve commit message generation, in: Proceedings of the 16th International Conference on Internetware (Internetware), ACM, 2025, pp. 389–401. 2.1 [8] P. Xue, L. Wu, Z. Yu, Z. Jin, Z. Yang, X. Li, Z. Yang, Y. Tan, Automated commit message generation with large language models: An empirical study and beyond, IEEE Transactions on Software Engineering 50 (12) (2024) 3208–3224. 2.1 [9] P. Lewis, E. Perez, A. Piktus, et al., Retrieval-augmented generation for knowledge-intensive nlp tasks, in: Proceedings of the 34th Annual Conference on Neural Information Processing Systems (NeurIPS), Curran Associates, Inc., 2020, pp. 9459–9474. 2.1 [10] Z. Feng, D. Guo, D. Tang, Y. Duan, X. Feng, M. Gong, L. Shou, B. Qin, T. Liu, T. Jiang, et al., Codebert: A pre-trained model for programming and natural languages, arXiv preprint arXiv:2002.08155 (2020). 4.2 [11] Conventional commits, accessed: 2026-05-01 (2023). URL https://www.conventionalcommits.org 5 [12] K. Papineni, S. Roukos, T. Ward, W.-J. Zhu, Bleu: a method for automatic evaluation of machine translation, in: Proceedings of the 40th Annual Meeting of the Association for Computational Linguistics (ACL), ACL, 2002, pp. 311–318. 5 [13] R. Vedantam, C. L. Zitnick, D. Parikh, Cider: Consensus-based image description evaluation, in: Proceedings of the 28th IEEE Conference on Computer Vision and Pattern Recognition (CVPR), IEEE, 2015, pp. 4566–4575. 5 [14] S. Banerjee, A. Lavie, Meteor: An automatic metric for mt evaluation with improved correlation with human judgments, in: Proceedings of the ACL Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization (MTSumm), ACL, 2005, pp. 65–72. 5
16
[15] C.-Y. Lin, Rouge: A package for automatic evaluation of summaries, in: Proceedings of the Text Summarization Branches Out: Proceedings of the ACL Workshop, ACL, 2004, pp. 74–81. 5 [16] L. Zhang, J. Zhao, C. Wang, P. Liang, Using large language models for commit message generation: A preliminary study, in: Proceedings of the 31st IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER), IEEE, 2024, pp. 126–130. 5
17