feat: Implement jinja support for user and system templates

CMakeLists.txt

@@ -11,7 +11,7 @@ set(CMAKE_CXX_EXTENSIONS OFF)
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
 find_package(QtCreator REQUIRED COMPONENTS Core)
-find_package(Qt6 COMPONENTS Core Gui Quick Widgets Network REQUIRED)
+find_package(Qt6 COMPONENTS Core Gui Quick Widgets Network Test REQUIRED)
 find_package(GTest)
 
 # IDE_VERSION is defined by QtCreator package
@@ -32,6 +32,9 @@ add_definitions(
   -DQODEASSIST_QT_CREATOR_VERSION_PATCH=${QODEASSIST_QT_CREATOR_VERSION_PATCH}
 )
 
+set(INJA_BUILD_TESTS OFF)
+
+add_subdirectory(3rdparty/inja)
 add_subdirectory(llmcore)
 add_subdirectory(settings)
 add_subdirectory(logger)
@@ -56,6 +59,7 @@ add_qtc_plugin(QodeAssist
     QtCreator::ExtensionSystem
     QtCreator::Utils
     QodeAssistChatViewplugin
+    inja
   SOURCES
     .github/workflows/build_cmake.yml
     .github/workflows/README.md

LLMClientInterface.cpp

@@ -34,6 +34,8 @@
 #include "settings/GeneralSettings.hpp"
 #include <llmcore/RequestConfig.hpp>
 
+#include <inja/inja.hpp>
+
 namespace QodeAssist {
 
 LLMClientInterface::LLMClientInterface(
@@ -221,26 +223,12 @@ void LLMClientInterface::handleCompletion(const QJsonObject &request)
     if (!stopWords.isEmpty())
         config.providerRequest["stop"] = stopWords;
 
-    QString systemPrompt;
-    if (m_completeSettings.useSystemPrompt())
-        systemPrompt.append(
-            m_completeSettings.useUserMessageTemplateForCC()
-                    && promptTemplate->type() == LLMCore::TemplateType::Chat
-                ? m_completeSettings.systemPromptForNonFimModels()
-                : m_completeSettings.systemPrompt());
-    if (updatedContext.fileContext.has_value())
-        systemPrompt.append(updatedContext.fileContext.value());
-
-    updatedContext.systemPrompt = systemPrompt;
+    updatedContext.systemPrompt
+        = buildSystemPrompt(promptTemplate, documentInfo, updatedContext.fileContext);
 
     if (promptTemplate->type() == LLMCore::TemplateType::Chat) {
-        QString userMessage;
-        if (m_completeSettings.useUserMessageTemplateForCC()) {
-            userMessage = m_completeSettings.processMessageToFIM(
-                updatedContext.prefix.value_or(""), updatedContext.suffix.value_or(""));
-        } else {
-            userMessage = updatedContext.prefix.value_or("") + updatedContext.suffix.value_or("");
-        }
+        QString userMessage = buildUserMessage(
+            documentInfo, updatedContext.prefix.value_or(""), updatedContext.suffix.value_or(""));
 
         // TODO refactor add message
         QVector<LLMCore::Message> messages;
@@ -263,6 +251,52 @@ void LLMClientInterface::handleCompletion(const QJsonObject &request)
     m_requestHandler.sendLLMRequest(config, request);
 }
 
+QString LLMClientInterface::buildSystemPrompt(
+    const LLMCore::PromptTemplate *promptTemplate,
+    const Context::DocumentInfo &documentInfo,
+    const std::optional<QString> &fileContext) const
+{
+    QString prompt;
+    if (m_completeSettings.useSystemPrompt()) {
+        auto templateString = m_completeSettings.useUserMessageTemplateForCC()
+                                      && promptTemplate->type() == LLMCore::TemplateType::Chat
+                                  ? m_completeSettings.systemPromptForNonFimModelsJinja()
+                                  : m_completeSettings.systemPromptJinja();
+
+        inja::json json;
+        json["mime_type"] = documentInfo.mimeType.toStdString();
+        json["language"] = Context::ProgrammingLanguageUtils::toString(
+                               Context::ContextManager::getDocumentLanguage(documentInfo))
+                               .toStdString();
+        prompt.append(QString::fromStdString(inja::render(templateString.toStdString(), json)));
+    }
+
+    if (fileContext.has_value()) {
+        prompt.append(fileContext.value());
+    }
+
+    return prompt;
+}
+
+QString LLMClientInterface::buildUserMessage(
+    const Context::DocumentInfo &documentInfo, const QString &prefix, const QString &suffix) const
+{
+    if (!m_completeSettings.useUserMessageTemplateForCC()) {
+        return prefix + suffix;
+    }
+
+    auto templateString = m_completeSettings.userMessageTemplateForCCjinja();
+
+    inja::json json;
+    json["mime_type"] = documentInfo.mimeType.toStdString();
+    json["language"] = Context::ProgrammingLanguageUtils::toString(
+                           Context::ContextManager::getDocumentLanguage(documentInfo))
+                           .toStdString();
+    json["prefix"] = prefix.toStdString();
+    json["suffix"] = suffix.toStdString();
+    return QString::fromStdString(inja::render(templateString.toStdString(), json));
+}
+
 LLMCore::ContextData LLMClientInterface::prepareContext(
     const QJsonObject &request, const Context::DocumentInfo &documentInfo)
 {

LLMClientInterface.hpp

@@ -58,9 +58,11 @@ class LLMClientInterface : public LanguageClient::BaseClientInterface
 
     void handleCompletion(const QJsonObject &request);
 
+    // exposed for tests
+    void sendData(const QByteArray &data) override;
+
 protected:
     void startImpl() override;
-    void sendData(const QByteArray &data) override;
     void parseCurrentMessage() override;
 
 private:
@@ -71,6 +73,16 @@ class LLMClientInterface : public LanguageClient::BaseClientInterface
     void handleExit(const QJsonObject &request);
     void handleCancelRequest(const QJsonObject &request);
 
+    QString buildSystemPrompt(
+        const LLMCore::PromptTemplate *promptTemplate,
+        const Context::DocumentInfo &documentInfo,
+        const std::optional<QString> &fileContext) const;
+
+    QString buildUserMessage(
+        const Context::DocumentInfo &documentInfo,
+        const QString &prefix,
+        const QString &suffix) const;
+
     LLMCore::ContextData prepareContext(
         const QJsonObject &request, const Context::DocumentInfo &documentInfo);
 

settings/CMakeLists.txt

@@ -22,5 +22,6 @@ target_link_libraries(QodeAssistSettings
     QtCreator::Core
     QtCreator::Utils
     QodeAssistLogger
+    inja
 )
 target_include_directories(QodeAssistSettings PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})

settings/CodeCompletionSettings.cpp

@@ -42,6 +42,9 @@ CodeCompletionSettings::CodeCompletionSettings()
 
     setDisplayName(Tr::tr("Code Completion"));
 
+    configVersion.setSettingsKey(Constants::CC_CONFIG_VERSION);
+    configVersion.setDefaultValue(Constants::CC_CONFIG_VERSION_LATEST);
+
     // Auto Completion Settings
     autoCompletion.setSettingsKey(Constants::CC_AUTO_COMPLETION);
     autoCompletion.setLabelText(Tr::tr("Enable Auto Complete"));
@@ -150,21 +153,29 @@ CodeCompletionSettings::CodeCompletionSettings()
     useSystemPrompt.setLabelText(Tr::tr("Use System Prompt"));
 
     systemPrompt.setSettingsKey(Constants::CC_SYSTEM_PROMPT);
-    systemPrompt.setDisplayStyle(Utils::StringAspect::TextEditDisplay);
-    systemPrompt.setDefaultValue(
-        "You are an expert C++, Qt, and QML code completion assistant. Your task is to provide "
+
+    systemPromptJinja.setSettingsKey(Constants::CC_SYSTEM_PROMPT_JINJA);
+    systemPromptJinja.setDisplayStyle(Utils::StringAspect::TextEditDisplay);
+    systemPromptJinja.setDefaultValue(
+        "You are an expert {{ language }} code completion assistant. Your task is to provide "
         "precise and contextually appropriate code completions.\n\n");
+    systemPromptJinja.setToolTip(
+        Tr::tr("The setting uses Jinja format. The following keys are available:\n"
+               " - language (string): Programming language for the current file\n"
+               " - mime_type (string): MIME type of the current file\n"));
 
     useUserMessageTemplateForCC.setSettingsKey(Constants::CC_USE_USER_TEMPLATE);
     useUserMessageTemplateForCC.setDefaultValue(true);
     useUserMessageTemplateForCC.setLabelText(
         Tr::tr("Use special system prompt and user message for non FIM models"));
 
     systemPromptForNonFimModels.setSettingsKey(Constants::CC_SYSTEM_PROMPT_FOR_NON_FIM);
-    systemPromptForNonFimModels.setDisplayStyle(Utils::StringAspect::TextEditDisplay);
-    systemPromptForNonFimModels.setLabelText(Tr::tr("System prompt for non FIM models:"));
-    systemPromptForNonFimModels.setDefaultValue(
-        "You are an expert C++, Qt, and QML code completion assistant. Your task is to provide "
+
+    systemPromptForNonFimModelsJinja.setSettingsKey(Constants::CC_SYSTEM_PROMPT_FOR_NON_FIM_JINJA);
+    systemPromptForNonFimModelsJinja.setDisplayStyle(Utils::StringAspect::TextEditDisplay);
+    systemPromptForNonFimModelsJinja.setLabelText(Tr::tr("System prompt for non FIM models:"));
+    systemPromptForNonFimModelsJinja.setDefaultValue(
+        "You are an expert {{ language }} code completion assistant. Your task is to provide "
         "precise and contextually appropriate code completions.\n\n"
         "Core Requirements:\n"
         "1. Continue code exactly from the cursor position, ensuring it properly connects with any "
@@ -178,19 +189,32 @@ CodeCompletionSettings::CodeCompletionSettings()
         "- Ensure seamless integration with code both before and after the cursor\n\n"
         "Context Format:\n"
         "<code_context>\n"
-        "{{code before cursor}}<cursor>{{code after cursor}}\n"
+        "[[code before cursor]]<cursor>[[code after cursor]]\n"
         "</code_context>\n\n"
         "Response Format:\n"
         "- No explanations or comments\n"
         "- Only include new characters needed to create valid code\n"
         "- Should be codeblock with language\n");
+    systemPromptForNonFimModelsJinja.setToolTip(
+        Tr::tr("The setting uses Jinja format. The following keys are available:\n"
+               " - language (string): Programming language for the current file\n"
+               " - mime_type (string): MIME type of the current file"));
 
     userMessageTemplateForCC.setSettingsKey(Constants::CC_USER_TEMPLATE);
-    userMessageTemplateForCC.setDisplayStyle(Utils::StringAspect::TextEditDisplay);
-    userMessageTemplateForCC.setLabelText(Tr::tr("User message for non FIM models:"));
-    userMessageTemplateForCC.setDefaultValue(
+
+    userMessageTemplateForCCjinja.setSettingsKey(Constants::CC_USER_TEMPLATE_JINJA);
+    userMessageTemplateForCCjinja.setDisplayStyle(Utils::StringAspect::TextEditDisplay);
+    userMessageTemplateForCCjinja.setLabelText(Tr::tr("User message for non FIM models:"));
+    userMessageTemplateForCCjinja.setToolTip(
+        Tr::tr("The setting uses Jinja format. The following keys are available:\n"
+               " - language (string): Programming language for the current file\n"
+               " - mime_type (string): MIME type of the current file\n"
+               " - prefix (string): The code of the current file before the cursor\n"
+               " - suffix (string): The code of the current file after the cursor"));
+
+    userMessageTemplateForCCjinja.setDefaultValue(
         "Here is the code context with insertion points:\n"
-        "<code_context>\n${prefix}<cursor>${suffix}\n</code_context>\n\n");
+        "<code_context>\n{{ prefix }}<cursor>{{ suffix }}\n</code_context>\n\n");
 
     useProjectChangesCache.setSettingsKey(Constants::CC_USE_PROJECT_CHANGES_CACHE);
     useProjectChangesCache.setDefaultValue(true);
@@ -222,8 +246,14 @@ CodeCompletionSettings::CodeCompletionSettings()
 
     resetToDefaults.m_buttonText = Tr::tr("Reset Page to Defaults");
 
+    bool hasSavedConfigVersion = hasSavedSetting(&configVersion);
+
     readSettings();
 
+    if (!hasSavedConfigVersion || configVersion() < Constants::CC_CONFIG_VERSION_1_JINJA_TEMPLATES) {
+        upgradeOldTemplatesToJinja();
+    }
+
     readFileParts.setValue(!readFullFile.value());
 
     setupConnections();
@@ -252,13 +282,13 @@ CodeCompletionSettings::CodeCompletionSettings()
         auto contextItem = Column{
             Row{contextGrid, Stretch{1}},
             Row{useSystemPrompt, Stretch{1}},
-            Group{title(Tr::tr("Prompts for FIM models")), Column{systemPrompt}},
+            Group{title(Tr::tr("Prompts for FIM models")), Column{systemPromptJinja}},
             Group{
                 title(Tr::tr("Prompts for Non FIM models")),
                 Column{
                     Row{useUserMessageTemplateForCC, Stretch{1}},
-                    systemPromptForNonFimModels,
-                    userMessageTemplateForCC,
+                    systemPromptForNonFimModelsJinja,
+                    userMessageTemplateForCCjinja,
                 }},
             Row{useProjectChangesCache, maxChangesCacheSize, Stretch{1}}};
 
@@ -347,23 +377,38 @@ void CodeCompletionSettings::resetSettingsToDefaults()
         resetAspect(readStringsBeforeCursor);
         resetAspect(readStringsAfterCursor);
         resetAspect(useSystemPrompt);
-        resetAspect(systemPrompt);
+        resetAspect(systemPromptJinja);
         resetAspect(useProjectChangesCache);
         resetAspect(maxChangesCacheSize);
         resetAspect(ollamaLivetime);
         resetAspect(contextWindow);
         resetAspect(useUserMessageTemplateForCC);
-        resetAspect(userMessageTemplateForCC);
-        resetAspect(systemPromptForNonFimModels);
+        resetAspect(userMessageTemplateForCCjinja);
+        resetAspect(systemPromptForNonFimModelsJinja);
     }
 }
 
-QString CodeCompletionSettings::processMessageToFIM(const QString &prefix, const QString &suffix) const
+void CodeCompletionSettings::upgradeOldTemplatesToJinja()
 {
-    QString result = userMessageTemplateForCC();
-    result.replace("${prefix}", prefix);
-    result.replace("${suffix}", suffix);
-    return result;
+    {
+        QString newTemplate = userMessageTemplateForCC();
+        newTemplate.replace("${prefix}", "{{ prefix }}");
+        newTemplate.replace("${suffix}", "{{ suffix }}");
+        userMessageTemplateForCCjinja.setValue(newTemplate);
+    }
+    {
+        QString newTemplate = systemPromptForNonFimModels();
+        newTemplate.replace(
+            "{{code before cursor}}<cursor>{{code after cursor}}",
+            "[[code before cursor]]<cursor>[[code after cursor]]");
+        newTemplate.replace("C++, Qt, and QML", "{{ language }}");
+        systemPromptForNonFimModelsJinja.setValue(newTemplate);
+    }
+    {
+        QString newTemplate = systemPrompt();
+        newTemplate.replace("C++, Qt, and QML", "{{ language }}");
+        systemPromptJinja.setValue(newTemplate);
+    }
 }
 
 class CodeCompletionSettingsPage : public Core::IOptionsPage

settings/CodeCompletionSettings.hpp

@@ -32,6 +32,8 @@ class CodeCompletionSettings : public Utils::AspectContainer
 
     ButtonAspect resetToDefaults{this};
 
+    Utils::IntegerAspect configVersion{this}; // used to track config version for upgrades
+
     // Auto Completion Settings
     Utils::BoolAspect autoCompletion{this};
     Utils::BoolAspect multiLineCompletion{this};
@@ -65,10 +67,10 @@ class CodeCompletionSettings : public Utils::AspectContainer
     Utils::IntegerAspect readStringsBeforeCursor{this};
     Utils::IntegerAspect readStringsAfterCursor{this};
     Utils::BoolAspect useSystemPrompt{this};
-    Utils::StringAspect systemPrompt{this};
+    Utils::StringAspect systemPromptJinja{this};
     Utils::BoolAspect useUserMessageTemplateForCC{this};
-    Utils::StringAspect systemPromptForNonFimModels{this};
-    Utils::StringAspect userMessageTemplateForCC{this};
+    Utils::StringAspect systemPromptForNonFimModelsJinja{this};
+    Utils::StringAspect userMessageTemplateForCCjinja{this};
     Utils::BoolAspect useProjectChangesCache{this};
     Utils::IntegerAspect maxChangesCacheSize{this};
 
@@ -79,11 +81,17 @@ class CodeCompletionSettings : public Utils::AspectContainer
     // API Configuration Settings
     Utils::StringAspect apiKey{this};
 
-    QString processMessageToFIM(const QString &prefix, const QString &suffix) const;
-
 private:
+    // The aspects below only exist to fetch configuration from settings produced
+    // by old versions of the plugin. This configuration is used to fill in new versions
+    // of these settings so that users do not need to upgrade manually.
+    Utils::StringAspect systemPrompt{this};
+    Utils::StringAspect systemPromptForNonFimModels{this};
+    Utils::StringAspect userMessageTemplateForCC{this};
+
     void setupConnections();
     void resetSettingsToDefaults();
+    void upgradeOldTemplatesToJinja();
 };
 
 CodeCompletionSettings &codeCompletionSettings();

settings/SettingsConstants.hpp

@@ -54,6 +54,7 @@ const char CC_PRESET1_URL_HISTORY[] = "QodeAssist.ccPreset1UrlHistory";
 
 // settings
 const char ENABLE_QODE_ASSIST[] = "QodeAssist.enableQodeAssist";
+const char CC_CONFIG_VERSION[] = "QodeAssist.ccConfigVersion";
 const char CC_AUTO_COMPLETION[] = "QodeAssist.ccAutoCompletion";
 const char ENABLE_LOGGING[] = "QodeAssist.enableLogging";
 const char ENABLE_CHECK_UPDATE[] = "QodeAssist.enableCheckUpdate";
@@ -107,9 +108,12 @@ const char CC_READ_STRINGS_BEFORE_CURSOR[] = "QodeAssist.ccReadStringsBeforeCurs
 const char CC_READ_STRINGS_AFTER_CURSOR[] = "QodeAssist.ccReadStringsAfterCursor";
 const char CC_USE_SYSTEM_PROMPT[] = "QodeAssist.ccUseSystemPrompt";
 const char CC_SYSTEM_PROMPT[] = "QodeAssist.ccSystemPrompt";
+const char CC_SYSTEM_PROMPT_JINJA[] = "QodeAssist.ccSystemPromptJinja";
 const char CC_SYSTEM_PROMPT_FOR_NON_FIM[] = "QodeAssist.ccSystemPromptForNonFim";
+const char CC_SYSTEM_PROMPT_FOR_NON_FIM_JINJA[] = "QodeAssist.ccSystemPromptForNonFimJinja";
 const char CC_USE_USER_TEMPLATE[] = "QodeAssist.ccUseUserTemplate";
 const char CC_USER_TEMPLATE[] = "QodeAssist.ccUserTemplate";
+const char CC_USER_TEMPLATE_JINJA[] = "QodeAssist.ccUserTemplateJinja";
 const char CC_USE_PROJECT_CHANGES_CACHE[] = "QodeAssist.ccUseProjectChangesCache";
 const char CC_MAX_CHANGES_CACHE_SIZE[] = "QodeAssist.ccMaxChangesCacheSize";
 const char CA_USE_SYSTEM_PROMPT[] = "QodeAssist.useChatSystemPrompt";
@@ -143,4 +147,7 @@ const char CA_OLLAMA_LIVETIME[] = "QodeAssist.chatOllamaLivetime";
 const char CA_OLLAMA_CONTEXT_WINDOW[] = "QodeAssist.caOllamaContextWindow";
 const char CA_API_KEY[] = "QodeAssist.chatApiKey";
 
+const int CC_CONFIG_VERSION_1_JINJA_TEMPLATES = 1;
+const int CC_CONFIG_VERSION_LATEST = CC_CONFIG_VERSION_1_JINJA_TEMPLATES;
+
 } // namespace QodeAssist::Constants